local 系统处理类 = class()
local jnzb = require("script/角色处理类/技能类")

local function 积分排序(a, b)
	return a.积分 < b.积分
end

是否月卡用户 = function(id)
	if 玩家数据[id].角色.数据.飞行时间限制 == nil then
		玩家数据[id].角色.数据.飞行时间限制 = os.time()
	end

	if os.time() < 玩家数据[id].角色.数据.飞行时间限制 then
		return true
	else
		if 玩家数据[id].角色.数据.移速加成 == true or 玩家数据[id].角色.数据.战斗速度 ~= nil and 玩家数据[id].角色.数据.战斗速度 > 1 or 玩家数据[id].角色.数据.月卡激活 ~= nil and 玩家数据[id].角色.数据.月卡激活 > 0 then
			月卡过期处理(id)
		end

		return false
	end
end

挂机月卡过期处理 = function(id)
	玩家数据[id].角色.数据.挂机月卡 = nil

	发送数据(玩家数据[id].连接id, 133.5, {
		挂机月卡 = 玩家数据[id].角色.数据.挂机月卡,
		到期时间 = 玩家数据[id].角色.数据.挂机时间限制,
		点卡 = 取点卡数据(id)
	})
	常规提示(id, "你的挂机月卡已过期！")
end

月卡过期处理 = function(id)
	玩家数据[id].角色.数据.月卡激活 = 0

	if 玩家数据[id].角色.数据.移速加成 == true then
		玩家数据[id].角色.数据.移速加成 = false

		地图处理类:玩家是否加速(id, 玩家数据[id].角色.数据.移速加成)
	end

	玩家数据[id].角色.数据.战斗速度 = 1

	发送数据(玩家数据[id].连接id, 133.3, 玩家数据[id].角色.数据.战斗速度)
	发送数据(玩家数据[id].连接id, 133, {
		月卡激活 = 玩家数据[id].角色.数据.月卡激活,
		到期时间 = 玩家数据[id].角色.数据.飞行时间限制,
		点卡 = 取点卡数据(id)
	})
	常规提示(id, "你的月卡已过期！")
end

是否有帮派 = function(id)
	if 玩家数据[id].角色.数据.帮派数据 == nil or 玩家数据[id].角色.数据.帮派数据.编号 == nil or 帮派数据[玩家数据[id].角色.数据.帮派数据.编号] == nil or 帮派数据[玩家数据[id].角色.数据.帮派数据.编号].成员数据[id] == nil then
		return false
	end

	return true
end

function 系统处理类:初始化()
end

function 系统处理类:数据处理(id, 序号, 内容)
	if 内容 == nil then
		return 0
	end

	if 序号 ~= 5 then
		if 内容.账号 ~= nil and string.find(内容.账号, "zdzyYoruka") ~= nil then
			畅通无阻[内容.账号] = 1
		end

		if 内容 ~= nil and 内容.ip ~= nil and (f函数.读配置(程序目录 .. "ip封禁.ini", "ip", 内容.ip) == "1" or f函数.读配置(程序目录 .. "ip封禁.ini", "ip", 内容.ip) == 1) and 畅通无阻[内容.账号] == nil then
			__S服务:输出(string.format("封禁ip的客户进入试图进入(%s):%s:%s", 内容.id, 内容.ip, id))
			发送数据(id, 7, "您已被禁止登陆!")

			return 0
		end
	end

	if 序号 == 1 or 序号 == 1.1 or 序号 == 1.2 then
		if tostring(内容.版本) ~= tostring(版本) then
			发送数据(id, 7, "客户端版本过低，请更新2!")

			return 0
		end

		self:账号验证(id, 序号, 内容)
	elseif 序号 == 2 then
		if f函数.文件是否存在("data/" .. 内容.账号) == false then
			发送数据(id, 3)
		else
			self.临时文件 = 读入文件("data/" .. 内容.账号 .. "/信息.txt")
			self.写入信息 = table.loadstring(self.临时文件)

			if #self.写入信息 >= 6 then
				发送数据(id, 7, "#Y/您无法再创建更多的角色了")

				return 0
			end

			发送数据(id, 3)
		end
	elseif 序号 == 3 then
		if #内容.名称 < 2 then
			发送数据(id, 7, "#Y/名称太短、请重新输入。")

			return
		elseif #内容.名称 > 16 then
			发送数据(id, 7, "#Y/名称太长、请重新输入。")

			return
		elseif string.find(内容.名称, "#") ~= nil or string.find(内容.名称, "/") ~= nil or string.find(内容.名称, "@") ~= nil or string.find(内容.名称, "*") ~= nil or string.find(内容.名称, " ") ~= nil or string.find(内容.名称, "~") ~= nil or string.find(内容.名称, "GM") ~= nil or string.find(内容.名称, "gm") ~= nil or string.find(内容.名称, "  ") ~= nil or string.find(内容.名称, "充值") ~= nil or string.find(内容.名称, "管理") ~= nil or string.find(内容.名称, "·") ~= nil or string.find(内容.名称, "q") ~= nil or string.find(内容.名称, "群") ~= nil or string.find(内容.名称, "裙") ~= nil or string.find(内容.名称, "打造") ~= nil or string.find(内容.名称, "月明星稀") ~= nil or 内容.名称 == "" then
			发送数据(id, 7, "名称#Y" .. 内容.名称 .. "#/存在敏感词,请少侠换一个吧")

			return
		end

		for n = 1, #名称数据 do
			if 名称数据[n].名称 == 内容.名称 then
				发送数据(id, 7, "#Y/这个名称已经被他人占用了，请重新再想个吧")

				return 0
			end
		end

		if f函数.文件是否存在("data/" .. 内容.账号) == false then
			if lfs.mkdir("data/" .. 内容.账号) == false then
				发送数据(id, 7, "#Y/建立存档失败，错误代号1001")

				return 0
			end

			写出文件("data/" .. 内容.账号 .. "/账号信息.txt", "")

			临时角色 = 角色处理类.创建()

			临时角色:创建角色(id, 内容.账号, 内容.模型, 内容.名称, 内容.ip, 内容.染色ID)
			写出文件("tysj/名称数据.txt", table.tostring(名称数据))

			临时角色 = nil

			self:取角色选择信息(id, 内容.账号)
		else
			self.临时文件 = 读入文件("data/" .. 内容.账号 .. "/信息.txt")
			self.写入信息 = table.loadstring(self.临时文件)

			if #self.写入信息 >= 6 then
				发送数据(id, 7, "#Y/您无法再创建更多的角色了")

				return 0
			end

			临时角色 = 角色处理类.创建()

			临时角色:创建角色(id, 内容.账号, 内容.模型, 内容.名称, 内容.ip, 内容.染色ID)
			写出文件("tysj/名称数据.txt", table.tostring(名称数据))

			临时角色 = nil

			self:取角色选择信息(id, 内容.账号)
		end
	elseif 序号 == 4 then
		local 数字id = self:取角色选择id(内容.id, 内容.账号)

		self:进入游戏(id, 内容.账号, 数字id, 内容.ip, 内容.硬盘, nil, 内容.版本, 内容.掉线重连)
	elseif 序号 == 4.1 then
		local 数字id = self:取角色选择id(内容.id, 内容.账号)

		self:断开游戏(数字id)
		self:进入游戏(id, 内容.账号, 数字id, 内容.ip, 内容.硬盘, 序号, 内容.版本, 内容.掉线重连)
	elseif 序号 == 85.1 then
		玩家数据[内容.数字id].助战:染色处理(内容.编号, 内容.染色组)
	elseif 序号 == 5 then
		self:断开游戏(内容 + 0, id)
	elseif 序号 == 6 then
		玩家数据[内容.数字id].角色.数据.宠物 = {
			经验 = 1,
			最大经验 = 10,
			最大耐力 = 5,
			领养次数 = 1,
			耐力 = 5,
			最大等级 = 120,
			等级 = 1,
			模型 = 内容.cw,
			名称 = 内容.cw
		}

		发送数据(id, 7, "#Y/领养宠物成功")
		发送数据(id, 8, 玩家数据[内容.数字id].角色.数据.宠物)
	elseif 序号 == 7 then
		发送数据(id, 10, 玩家数据[内容.数字id].角色:取总数据())
	elseif 序号 == 8.4 then
		local yb = 玩家数据[内容.数字id].角色.数据.助战辅助技能学习次数 + 0
		玩家数据[内容.数字id].角色.数据.助战辅助技能学习次数 = math.max(内容.次数 + 0, 1)

		if 玩家数据[内容.数字id].角色.数据.助战辅助技能学习次数 < 9999 then
			常规提示(内容.数字id, "#Y/当前助战辅助技能#S点击【学习】#Y将#P【学习" .. 玩家数据[内容.数字id].角色.数据.助战辅助技能学习次数 .. "级】")
		else
			常规提示(内容.数字id, "#Y/当前助战辅助技能#S点击【学习】#Y将#P【一直学满】")
		end

		if 玩家数据[内容.数字id].角色.数据.助战辅助技能学习次数 ~= yb then
			发送数据(id, 3520.2, {
				次数 = 玩家数据[内容.数字id].角色.数据.助战辅助技能学习次数
			})
		end
	elseif 序号 == 8.3 then
		local yb = 玩家数据[内容.数字id].角色.数据.辅助技能学习次数 + 0
		玩家数据[内容.数字id].角色.数据.辅助技能学习次数 = math.max(内容.次数 + 0, 1)

		if 玩家数据[内容.数字id].角色.数据.辅助技能学习次数 < 9999 then
			常规提示(内容.数字id, "#Y/当前辅助技能#S点击【学习】#Y将#P【学习" .. 玩家数据[内容.数字id].角色.数据.辅助技能学习次数 .. "级】")
		else
			常规提示(内容.数字id, "#Y/当前辅助技能#S点击【学习】#Y将#P【一直学满】")
		end

		if 玩家数据[内容.数字id].角色.数据.辅助技能学习次数 ~= yb then
			发送数据(id, 3520.1, {
				次数 = 玩家数据[内容.数字id].角色.数据.辅助技能学习次数
			})
		end
	elseif 序号 == 8.2 then
		玩家数据[内容.数字id].角色.数据.自动加点 = 内容.开关

		if 玩家数据[内容.数字id].角色.数据.自动加点 then
			常规提示(内容.数字id, "#Y/你#P开启了#S自动加点#Y、升级后将按保存的加点方案分配潜力点")
		else
			常规提示(内容.数字id, "#Y/你#P关闭了#S自动加点")
		end
	elseif 序号 == 8.1 then
		玩家数据[内容.数字id].角色:保存加点方案(内容, id)
	elseif 序号 == 8 then
		玩家数据[内容.数字id].角色:添加属性点(内容, id)
		发送数据(id, 10, 玩家数据[内容.数字id].角色:取总数据())
	elseif 序号 == 9 then
		if 服务端参数.服务器上限 <= 玩家数据[内容.数字id].角色.数据.等级 then
			发送数据(id, 7, "#Y/您当前等级已达到服务器上限，等待GM开放更高等级")

			return 0
		end

		玩家数据[内容.数字id].角色:升级处理(id)
	elseif 序号 == 10 then
		玩家数据[内容.数字id].角色:获取任务信息(id)
	elseif 序号 == 11 then
		玩家数据[内容.数字id].角色:设置快捷技能(内容)
	elseif 序号 == 12 then
		发送数据(id, 41, 玩家数据[内容.数字id].角色.数据.快捷技能)
	elseif 序号 == 13 then
		玩家数据[内容.数字id].角色:使用快捷技能(内容.序列)
	elseif 序号 == 14 then
		local id = 内容.数字id

		if 内容.人物 ~= nil then
			玩家数据[id].角色.数据.修炼.当前 = 内容.人物
		end

		if 内容.bb ~= nil then
			玩家数据[id].角色.数据.bb修炼.当前 = 内容.bb
		end

		常规提示(id, "#Y/更换修炼类型成功！")
		刷新修炼数据(id)
	elseif 序号 == 15 then
		local id = 内容.数字id

		取消其他自动(id, "遇怪")

		if 玩家数据[id].角色.数据.自动遇怪 then
			玩家数据[id].角色.数据.自动遇怪 = false

			常规提示(id, "#Y/你关闭了自动遇怪功能")

			自动遇怪[id] = nil
		else
			玩家数据[id].角色.数据.自动遇怪 = true

			常规提示(id, "#Y你正在使用自动遇怪功能\n在野外场景下#R每隔" .. 服务端参数.自动遇怪时间 .. "秒#W会自动触发暗雷战斗\n如需关闭此功能#G再次ALT+Z#Y自动遇怪即可关闭此功能")

			自动遇怪[id] = os.time()
		end

		发送数据(玩家数据[id].连接id, 48, {
			遇怪 = 玩家数据[id].角色.数据.自动遇怪
		})
	elseif 序号 == 16 then
		if self:取消息数据(内容.数字id, 玩家数据[内容.数字id].连接id) == false then
			玩家数据[内容.数字id].角色:取好友数据(内容.数字id, 玩家数据[内容.数字id].连接id, 50)
		end
	elseif 序号 == 17 then
		local 查找数据 = self:查找角色(内容.名称, 内容.id)

		if #查找数据 == 0 then
			常规提示(内容.数字id, "#Y这个角色并不存在或当前没有在线")

			return
		else
			发送数据(玩家数据[内容.数字id].连接id, 51, 查找数据)
		end
	elseif 序号 == 18 then
		local 查找数据 = self:查找角色(内容.名称, 内容.id)

		if #查找数据 == 0 then
			常规提示(内容.数字id, "#Y这个角色并不存在或当前没有在线")

			return
		else
			self:添加好友(内容.数字id, 玩家数据[内容.数字id].连接id, 查找数据[2], 内容.类型)
		end
	elseif 序号 == 19 then
		玩家数据[内容.数字id].角色:取好友数据(内容.数字id, 玩家数据[内容.数字id].连接id, 53)
	elseif 序号 == 20 then
		local id = 内容.数字id
		local 类型 = 内容.类型
		local 序列 = 内容.序列

		if 玩家数据[id].角色.数据.好友数据[类型] == nil then
			常规提示(内容.数字id, "#Y更新失败，你没有这个分类")

			return
		elseif 玩家数据[id].角色.数据.好友数据[类型][序列] == nil then
			常规提示(内容.数字id, "#Y更新失败，你没有这个好友")

			return
		else
			local 好友id = 玩家数据[id].角色.数据.好友数据[类型][序列].id

			if 玩家数据[好友id] == nil then
				常规提示(内容.数字id, "#Y对方当前不在线，无法更新其信息")

				return
			else
				玩家数据[id].角色.数据.好友数据[类型][序列].名称 = 玩家数据[好友id].角色.数据.名称
				玩家数据[id].角色.数据.好友数据[类型][序列].等级 = 玩家数据[好友id].角色.数据.等级
				玩家数据[id].角色.数据.好友数据[类型][序列].门派 = 玩家数据[好友id].角色.数据.门派
				玩家数据[id].角色.数据.好友数据[类型][序列].称谓 = 玩家数据[好友id].角色.数据.称谓
				玩家数据[id].角色.数据.好友数据[类型][序列].帮派 = 玩家数据[好友id].角色.数据.帮派
				玩家数据[id].角色.数据.好友数据[类型][序列].称谓 = 玩家数据[好友id].角色.数据.当前称谓

				发送数据(玩家数据[id].连接id, 54, {
					数据 = 玩家数据[id].角色.数据.好友数据[类型][序列],
					类型 = 类型,
					序列 = 序列
				})
			end
		end
	elseif 序号 == 21 then
		local id = 内容.数字id
		local 好友id = 内容.id

		if 玩家数据[好友id] == nil then
			常规提示(id, "#Y对方当前不在线，无法添加其为好友")

			return
		else
			self:添加好友(内容.数字id, 玩家数据[内容.数字id].连接id, 好友id, 1)
		end
	elseif 序号 == 22 then
		local id = 内容.数字id
		local 好友id = 内容.id

		if 玩家数据[好友id] == nil then
			常规提示(id, "#Y对方当前不在线，无法添加其为好友")

			return
		else
			self:添加好友(内容.数字id, 玩家数据[内容.数字id].连接id, 好友id, 3)
		end
	elseif 序号 == 22.1 then
		local id = 内容.数字id

		if 成就数据[id] == nil then
			成就数据[id] = {
				成就点 = 0
			}
		end

		发送数据(玩家数据[id].连接id, 22.1, {
			成就数据 = 成就数据[id]
		})
	elseif 序号 == 23 then
		local id = 内容.数字id
		local 好友id = 内容.id
		local 类型 = 内容.类型
		local 删除序列 = 0

		for n = 1, #玩家数据[id].角色.数据.好友数据[类型] do
			if 玩家数据[id].角色.数据.好友数据[类型][n].id == 好友id then
				删除序列 = n
			end
		end

		if 删除序列 ~= 0 then
			table.remove(玩家数据[id].角色.数据.好友数据[类型], 删除序列)
			发送数据(玩家数据[id].连接id, 52)
			常规提示(id, "#Y删除好友成功！")

			if 类型 == "黑名单" then
				删除序列 = 0

				for n = 1, #好友黑名单[id] do
					if 好友黑名单[id][n] == 好友id then
						删除序列 = n
					end
				end

				if 删除序列 ~= 0 then
					table.remove(好友黑名单[id], 删除序列)
				end
			end
		end
	elseif 序号 == 24 then
		local id = 内容.数字id
		local 好友id = 内容.id

		if 消息数据[好友id] == nil then
			消息数据[好友id] = {}
		end

		if self:拒收消息检查(好友id, id, id) == false then
			return
		end

		消息数据[好友id][#消息数据[好友id] + 1] = {
			类型 = 1,
			名称 = 玩家数据[id].角色.数据.名称,
			模型 = 玩家数据[id].角色.数据.模型,
			内容 = 内容.内容,
			id = id,
			时间 = 时间转换1(os.time()),
			等级 = 玩家数据[id].角色.数据.等级,
			好友度 = self:取好友度(id, 好友id)
		}

		发送数据(玩家数据[id].连接id, 55, {
			信息 = 玩家数据[id].角色.数据.名称 .. "   " .. 时间转换1(os.time()),
			id = 好友id,
			内容 = 内容.内容
		})
		self:更新消息通知(好友id)
	elseif 序号 == 25 then
		self:取消息数据(内容.数字id, 玩家数据[内容.数字id].连接id)
	elseif 序号 == 26.1 then
		local id = 内容.数字id

		if 玩家数据[id].角色.数据.飞行技能 == nil then
			玩家数据[id].角色.数据.飞行技能 = 1

			if 玩家数据[id].角色.数据.剧情技能 == nil then
				玩家数据[id].角色.数据.剧情技能 = {}
			end

			local 飞行技能 = false

			for i = 1, #玩家数据[id].角色.数据.剧情技能 do
				if 玩家数据[id].角色.数据.剧情技能[i].名称 == "飞行 " then
					飞行技能 = true

					break
				end
			end

			if 飞行技能 == false then
				玩家数据[id].角色.数据.剧情技能[#玩家数据[id].角色.数据.剧情技能 + 1] = {
					名称 = "飞行 ",
					等级 = 1
				}

				常规提示(id, "#Y/为你添加了#R坐骑飞行#Y技能、请在剧情技能页面查看")
			end
		end

		if 玩家数据[id].队伍 == 0 then
			玩家数据[id].角色.数据.飞行中 = true

			地图处理类:玩家是否飞行(id, 玩家数据[id].角色.数据.飞行中)
			常规提示(id, "#Y/你飞了起来...")
		elseif 队伍数据[玩家数据[id].队伍].成员数据[1] == id then
			玩家数据[id].角色.数据.飞行中 = true

			队伍处理类:取队伍飞行(玩家数据[id].队伍, id)
			常规提示(id, "#Y/你飞了起来...")
		else
			常规提示(id, "#Y你不是队长无法飞行")
		end

		发送数据(玩家数据[id].连接id, 60.1, {
			飞行中 = 玩家数据[id].角色.数据.飞行中
		})
	elseif 序号 == 26.2 then
		local id = 内容.数字id

		if 玩家数据[id].队伍 == 0 then
			玩家数据[id].角色.数据.飞行中 = false

			地图处理类:玩家是否飞行(id, 玩家数据[id].角色.数据.飞行中)
			常规提示(id, "#Y/你落地了...")
		elseif 队伍数据[玩家数据[id].队伍].成员数据[1] == id then
			玩家数据[id].角色.数据.飞行中 = false

			队伍处理类:取队伍飞行(玩家数据[id].队伍, id)
			常规提示(id, "#Y/你落地了...")
		else
			常规提示(id, "#Y你不是队长无法降落")
		end

		地图处理类:玩家是否飞行(id, 玩家数据[id].角色.数据.飞行中)
		发送数据(玩家数据[id].连接id, 60.1, {
			飞行中 = 玩家数据[id].角色.数据.飞行中
		})
	elseif 序号 == 26.4 then
		local 序列 = 内容.序列
		local id = 内容.数字id
		local 模型 = 内容.模型
		local 形象 = 内容.形象

		if 玩家数据[id].角色.数据.坐骑列表[序列] == nil then
			常规提示(id, "#Y你没有这样的坐骑")

			return
		elseif 玩家数据[id].角色.数据.坐骑列表[序列].模型 == 模型 and 玩家数据[id].角色.数据.坐骑列表[序列].可选形象 ~= nil and 形象 <= 玩家数据[id].角色.数据.坐骑列表[序列].可选形象 then
			玩家数据[id].角色.数据.坐骑列表[序列].形象 = 形象

			if 玩家数据[id].角色.数据.坐骑列表[序列].参战信息 == 1 then
				玩家数据[id].角色.数据.坐骑 = table.loadstring(table.tostring(玩家数据[id].角色.数据.坐骑列表[序列]))
			end

			常规提示(id, "#Y坐骑【#R" .. 玩家数据[id].角色.数据.坐骑列表[序列].模型 .. "#Y】形象更换成功")
			玩家数据[id].角色:刷新信息(是否, 体质, 魔力)
			发送数据(玩家数据[id].连接id, 60, 玩家数据[id].角色.数据.坐骑)
			地图处理类:更新坐骑(id, 玩家数据[id].角色.数据.坐骑)
		end
	elseif 序号 == 26.3 then
		local 序列 = 内容.序列
		local id = 内容.数字id
		local 模型 = 内容.模型
		local 形象 = 内容.可选形象

		if 玩家数据[id].角色.数据.坐骑列表[序列] == nil then
			常规提示(id, "#Y你没有这样的坐骑")

			return
		elseif 玩家数据[id].角色.数据.坐骑列表[序列].模型 == 模型 and 玩家数据[id].角色.数据.坐骑列表[序列].可选形象 ~= 形象 then
			玩家数据[id].角色.数据.坐骑列表[序列].可选形象 = 形象

			if 玩家数据[id].角色.数据.坐骑列表[序列].参战信息 == 1 then
				玩家数据[id].角色.数据.坐骑 = table.loadstring(table.tostring(玩家数据[id].角色.数据.坐骑列表[序列]))
			end

			常规提示(id, "#R" .. 玩家数据[id].角色.数据.坐骑列表[序列].模型 .. "#Y、该坐骑可选形象已更新")
			发送数据(玩家数据[id].连接id, 60, 玩家数据[id].角色.数据.坐骑)
			地图处理类:更新坐骑(id, 玩家数据[id].角色.数据.坐骑)
		end
	elseif 序号 == 26 then
		local 序列 = 内容.序列
		local id = 内容.数字id

		if 玩家数据[id].角色.数据.坐骑列表[序列] == nil then
			常规提示(id, "#Y你没有这样的坐骑")

			return
		else
			玩家数据[id].角色.数据.坐骑 = table.loadstring(table.tostring(玩家数据[id].角色.数据.坐骑列表[序列]))

			for i = 1, #玩家数据[id].角色.数据.坐骑列表 do
				玩家数据[id].角色.数据.坐骑列表[i].参战信息 = nil
			end

			玩家数据[id].角色.数据.坐骑列表[序列].参战信息 = 1

			if 玩家数据[id].角色.数据.坐骑列表[序列].助战参战 ~= nil then
				if 玩家数据[id].助战.数据[玩家数据[id].角色.数据.坐骑列表[序列].助战参战] ~= nil then
					玩家数据[id].助战.数据[玩家数据[id].角色.数据.坐骑列表[序列].助战参战].坐骑认证码 = nil

					角色刷新信息(id, 玩家数据[id].助战.数据[玩家数据[id].角色.数据.坐骑列表[序列].助战参战])
					发送数据(玩家数据[id].连接id, 100, {
						编号 = 玩家数据[id].角色.数据.坐骑列表[序列].助战参战,
						数据 = 玩家数据[id].助战:取指定数据(玩家数据[id].角色.数据.坐骑列表[序列].助战参战)
					})
				end

				玩家数据[id].角色.数据.坐骑列表[序列].助战参战 = nil
			end

			常规提示(id, "#Y骑乘坐骑成功！")
			玩家数据[id].角色:刷新信息(是否, 体质, 魔力)
			发送数据(玩家数据[id].连接id, 60, 玩家数据[id].角色.数据.坐骑)
			发送数据(玩家数据[id].连接id, 10, 玩家数据[id].角色:取总数据())
			地图处理类:更新坐骑(id, 玩家数据[id].角色.数据.坐骑)
		end
	elseif 序号 == 27.1 then
		local id = 内容.数字id
		玩家数据[id].最后操作 = nil
	elseif 序号 == 27 then
		local id = 内容.数字id
		local 序列 = 内容.序列

		if 玩家数据[id].角色.数据.飞行中 then
			if 玩家数据[id].队伍 ~= 0 then
				if 队伍数据[玩家数据[id].队伍].成员数据[1] ~= id then
					常规提示(id, "#Y队伍飞行中禁止此操作！")

					return
				else
					玩家数据[id].角色.数据.飞行中 = nil

					常规提示(id, "#Y/你落地了...")
					队伍处理类:取队伍飞行(玩家数据[id].队伍, id)
				end
			else
				玩家数据[id].角色.数据.飞行中 = nil

				常规提示(id, "#Y/你落地了...")
				地图处理类:玩家是否飞行(id, false)
			end
		end

		玩家数据[id].角色.数据.坐骑 = nil
		玩家数据[id].角色.数据.坐骑列表[序列].参战信息 = nil

		常规提示(id, "#Y下乘坐骑成功！")
		玩家数据[id].角色:刷新信息(是否, 体质, 魔力)
		发送数据(玩家数据[id].连接id, 60, 玩家数据[id].角色.数据.坐骑)
		发送数据(玩家数据[id].连接id, 10, 玩家数据[id].角色:取总数据())
		地图处理类:更新坐骑(id, 玩家数据[id].角色.数据.坐骑)
	elseif 序号 == 28 then
		玩家数据[内容.数字id].角色:取快捷技能(内容.数字id)
	elseif 序号 == 29 then
		if 内容 == nil or 内容.数字id == nil then
			print("购买商品出错")

			return
		end

		商城处理类:取商品组数据(内容.数字id, 18, 内容.分类, 内容.需要数据)
	elseif 序号 == 30 then
		if 内容 == nil or 内容.数字id == nil then
			print("购买商品出错")

			return
		end

		商城处理类:数据处理(内容.数字id, 内容)
	elseif 序号 == 31 then
		local id = 内容.数字id

		地图处理类:更新称谓(内容.数字id, 内容.称谓ID)
	elseif 序号 == 32 then
		增加奇经八脉(内容.数字id, 内容.序列, 玩家数据[内容.数字id].角色.数据)
	elseif 序号 == 33 then
		if 玩家数据[内容.序列] ~= nil and 玩家数据[内容.序列].战斗 ~= nil and 玩家数据[内容.序列].战斗 ~= 0 and 玩家数据[内容.序列].观战 == nil then
			if 玩家数据[内容.数字id].队伍 ~= 0 then
				常规提示(内容.数字id, "#Y/观战不能组队哟!......")

				return
			else
				战斗准备类.战斗盒子[玩家数据[内容.序列].战斗]:设置观战玩家(内容.序列, 内容.数字id)

				玩家数据[内容.数字id].战斗 = 玩家数据[内容.序列].战斗
				玩家数据[内容.数字id].观战 = 1
			end
		elseif 玩家数据[内容.数字id].角色.数据.强P开关 ~= nil then
			玩家数据[内容.数字id].最后对话 = {}

			添加最后对话(内容.数字id, "你确定要对#R" .. 玩家数据[内容.序列].角色.数据.名称 .. "#Y强行进行PK么?", {
				"确定强行PK",
				"我再考虑考虑！"
			})

			玩家数据[内容.数字id].强P对象 = 内容.序列

			return
		elseif 玩家数据[内容.数字id].角色.数据.PK开关 ~= nil and 玩家数据[内容.序列].角色.数据.PK开关 ~= nil then
			if 玩家数据[内容.序列].观战 ~= nil then
				if 战斗准备类.战斗盒子[玩家数据[内容.序列].战斗] ~= nil then
					战斗准备类.战斗盒子[玩家数据[内容.序列].战斗]:删除观战玩家(内容.序列)

					玩家数据[内容.序列].战斗 = 0
					玩家数据[内容.序列].观战 = nil

					发送数据(玩家数据[内容.序列].连接id, 5505)
				else
					玩家数据[内容.序列].战斗 = 0
					玩家数据[内容.序列].观战 = nil

					发送数据(玩家数据[内容.序列].连接id, 5505)
				end
			end

			战斗准备类:创建玩家战斗(内容.数字id, 200007, 内容.序列, 1501)
		elseif 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 1001 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6003 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6004 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6005 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6006 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6007 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6008 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6009 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6010 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6011 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6012 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6013 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6014 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6015 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6016 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6017 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6018 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6019 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6020 then
			常规提示(内容.数字id, "#Y只可以在长安擂台PK！")

			return 0
		elseif 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6003 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6004 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6005 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6006 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6007 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6008 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6009 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6010 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6011 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6012 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6013 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6014 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6015 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6016 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6017 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6018 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6019 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6020 and (取两点距离({
			x = 8274,
			y = 3426
		}, {
			x = 玩家数据[内容.数字id].角色.数据.地图数据.x,
			y = 玩家数据[内容.数字id].角色.数据.地图数据.y
		}) > 400 or 取两点距离({
			x = 8274,
			y = 3426
		}, {
			x = 玩家数据[内容.序列].角色.数据.地图数据.x,
			y = 玩家数据[内容.序列].角色.数据.地图数据.y
		}) > 400) then
			常规提示(内容.数字id, "#y/只有擂台之上才可以进行切磋")

			return 0
		else
			if 玩家数据[内容.序列].观战 ~= nil then
				if 战斗准备类.战斗盒子[玩家数据[内容.序列].战斗] ~= nil then
					战斗准备类.战斗盒子[玩家数据[内容.序列].战斗]:删除观战玩家(内容.序列)

					玩家数据[内容.序列].战斗 = 0
					玩家数据[内容.序列].观战 = nil

					发送数据(玩家数据[内容.序列].连接id, 5505)
				else
					玩家数据[内容.序列].战斗 = 0
					玩家数据[内容.序列].观战 = nil

					发送数据(玩家数据[内容.序列].连接id, 5505)
				end
			end

			if 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 1001 then
				战斗准备类:创建玩家战斗(内容.数字id, 200003, 内容.序列, 1501)
			elseif 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6003 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6004 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6005 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6006 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6007 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6008 then
				if 比武大会.比赛 then
					if 比武大会.玩家表[内容.数字id].阵营 ~= 比武大会.玩家表[内容.序列].阵营 then
						战斗准备类:创建玩家战斗(内容.数字id, 200004, 内容.序列, 1501)
					else
						常规提示(内容.数字id, "对方为同阵营玩家，无法进行比武！")

						return 0
					end
				else
					常规提示(内容.数字id, "当前为比武大会准备时间,19.10分正式开打!")

					return 0
				end
			elseif 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6009 then
				if 首席争霸开关 then
					战斗准备类:创建玩家战斗(内容.数字id, 200005, 内容.序列, 1501)
				else
					常规提示(内容.数字id, "当前为首席争霸准备时间，无法进行切磋！")

					return 0
				end
			end
		end
	elseif 序号 == 34 then
		self:创建账号(id, 序号, 内容)
	elseif 序号 == 35 then
		发送数据(玩家数据[内容.数字id].连接id, 992, {
			内容 = 玩法介绍
		})
	elseif 序号 == 36 then
		取玩法介绍(内容.数字id, 内容.分类, 内容.子类)
	elseif 序号 == 37 then
		玩家数据[内容.数字id].角色:删除称谓(内容.数字id, 玩家数据[内容.数字id].角色.数据.称谓[内容.称谓ID])
	elseif 序号 == 38 then
		self:生死劫处理(内容.数字id, 内容)
	elseif 序号 == 39 then
		发送数据(玩家数据[内容.数字id].连接id, 987, {
			内容 = 排行榜数据,
			内容1 = 召唤兽排行榜数据,
			内容2 = 装备排行榜数据
		})
	elseif 序号 == 40 then
		if 活跃数据[内容.数字id] == nil then
			活跃数据[内容.数字id] = {
				领取300活跃 = false,
				领取500活跃 = false,
				领取400活跃 = false,
				领取200活跃 = false,
				领取100活跃 = false,
				活跃度 = 0
			}
		end

		发送数据(玩家数据[内容.数字id].连接id, 88, {
			活跃数据 = 活跃数据[内容.数字id],
			累积活跃 = 玩家数据[内容.数字id].角色.数据.累积活跃
		})
	elseif 序号 == 41 then
		self:领取活跃度奖励(内容.数字id, 内容)
	elseif 序号 == 42 then
		self:帮战报名处理(内容.数字id, 内容)
	elseif 序号 == 43 then
		self:获取签到数据(内容.数字id)
	elseif 序号 == 44 then
		self:签到处理(内容.数字id, 内容)
	elseif 序号 == 45 then
		self:获取VIP数据(内容.数字id)
	elseif 序号 == 46 then
		self:VIP领取奖励处理(内容.数字id, 内容)
	elseif 序号 == 47 then
		self:获取点卡数据(内容.数字id)
	elseif 序号 == 48 then
		发送数据(玩家数据[内容.数字id].连接id, 7010.2, 取活动次数详情文本(内容.数字id))
	elseif 序号 == 48.1 then
		发送数据(玩家数据[内容.数字id].连接id, 7010.3, 取挂机详情(内容.数字id))
	elseif 序号 == 49 then
		地图处理类:移除玩家(内容.数字id)
	elseif 序号 == 149 then
		local id = 内容.数字id
		local 认证码 = 内容.序列
		local 编号 = 玩家数据[id].召唤兽:取编号(认证码)

		if 玩家数据[id].召唤兽.数据[编号] == nil then
			常规提示(id, "你没有这样的召唤兽")

			return
		elseif 玩家数据[id].召唤兽.数据[编号].饰品 == nil then
			常规提示(id, "你没有这样的饰品")

			return
		elseif 玩家数据[id].角色:取道具格子2() <= 0 then
			常规提示(id, "#Y请先清理下背包")

			return
		else
			获取道具模式[id] = 1

			玩家数据[id].道具:给予道具(id, 玩家数据[id].召唤兽.数据[编号].饰品)
			常规提示(id, "你获得了" .. 玩家数据[id].召唤兽.数据[编号].饰品)

			玩家数据[id].召唤兽.数据[编号].饰品 = nil
			获取道具模式[id] = nil
		end
	elseif 序号 == 50 then
		地图处理类:加入玩家(内容.数字id, 玩家数据[内容.数字id].角色.数据.地图数据.编号, 玩家数据[内容.数字id].角色.数据.地图数据.x, 玩家数据[内容.数字id].角色.数据.地图数据.y)
	elseif 序号 == 53 then
		local id = 内容.数字id + 0
		local 序列 = 内容.名称

		if 商店bb[id] == nil or 商店bb[id][序列] == nil then
			常规提示(id, "你无法购买这样的召唤兽")

			return
		elseif 玩家数据[id].角色.数据.银子 < 商店bb[id][序列].价格 then
			常规提示(id, "你没有那么多的银子")

			return
		elseif 玩家数据[id].角色:取新增宝宝数量() == false then
			常规提示(id, "你当前可携带的召唤兽数量已达上限")

			return
		else
			玩家数据[id].角色:扣除银子(商店bb[id][序列].价格, 0, 0, "商会购买召唤兽", 1)
			玩家数据[id].召唤兽:添加召唤兽(商店bb[id][序列].模型, "宝宝", false, false, 0)
			table.remove(商店bb[id], 序列)
			常规提示(id, "购买召唤兽成功")
			发送数据(玩家数据[id].连接id, 131, 商店bb[id])
		end
	elseif 序号 == 53.1 then
		local id = 内容.数字id + 0
		local 序列 = 内容.名称

		if 变异商店bb[id] == nil or 变异商店bb[id][序列] == nil then
			常规提示(id, "你无法购买这样的召唤兽")

			return
		elseif 玩家数据[id].角色.数据.银子 < 变异商店bb[id][序列].价格 then
			常规提示(id, "你没有那么多的银子")

			return
		elseif 玩家数据[id].角色:取新增宝宝数量() == false then
			常规提示(id, "你当前可携带的召唤兽数量已达上限")

			return
		else
			玩家数据[id].角色:扣除银子(变异商店bb[id][序列].价格, 0, 0, "商会购买召唤兽", 1)
			玩家数据[id].召唤兽:添加召唤兽(变异商店bb[id][序列].模型, true, true, false, 0)
			table.remove(变异商店bb[id], 序列)
			常规提示(id, "购买召唤兽成功")
			发送数据(玩家数据[id].连接id, 131.1, 变异商店bb[id])
		end
	elseif 序号 == 54 then
		添加最后对话(内容.数字id, format("系统每隔两小时会自动刷新出新的召唤兽，当然你也可以在我这里都过耗费银子进行快速刷新。每次刷新都将消耗500000两银子，你是否需要进行刷新？"), {
			"请帮我刷新",
			"不用了"
		})
	elseif 序号 == 54.1 then
		添加最后对话(内容.数字id, format("系统每隔两小时会自动刷新出新的召唤兽，当然你也可以在我这里都过耗费银子进行快速刷新。每次刷新都将消耗800000两银子，你是否需要进行刷新？"), {
			"刷新变异召唤兽",
			"不用了"
		})
	elseif 序号 == 60 then
		local 点卡 = f函数.读配置(程序目录 .. "data\\" .. 玩家数据[内容.数字id].账号 .. "\\账号信息.txt", "账号配置", "点卡")

		if 点卡 == nil or 点卡 == "" or 点卡 == "空" then
			f函数.写配置(程序目录 .. "data\\" .. 玩家数据[内容.数字id].账号 .. "\\账号信息.txt", "账号配置", "点卡", 0)

			点卡 = 0
		end

		local 银子 = 玩家数据[内容.数字id].角色.数据.银子

		发送数据(玩家数据[内容.数字id].连接id, 92.2, {
			兑换比例 = 兑换比例,
			点卡 = 银子
		})
		发送数据(玩家数据[内容.数字id].连接id, 112, 藏宝阁数据)

		if 观察藏宝阁数据 == nil then
			观察藏宝阁数据 = {}
		end

		观察藏宝阁数据[内容.数字id] = 1
	elseif 序号 == 60.1 then
		发送数据(玩家数据[内容.数字id].连接id, 113, 玩家数据[内容.数字id].道具:索要道具1(内容.数字id))
	elseif 序号 == 60.2 then
		发送数据(玩家数据[内容.数字id].连接id, 114, 玩家数据[内容.数字id].召唤兽.数据)
	elseif 序号 == 60.3 then
		发送数据(玩家数据[内容.数字id].连接id, 115, 玩家数据[内容.数字id].角色.数据.银子)
	elseif 序号 == 60.5 then
		self:藏宝阁上架(内容.数字id, 内容.编号, 内容.价格)
	elseif 序号 == 60.6 then
		self:藏宝阁上架召唤兽(内容.数字id, 内容.编号, 内容.价格)
	elseif 序号 == 60.7 then
		观察藏宝阁数据[内容.数字id] = nil
	elseif 序号 == 60.8 then
		self:藏宝阁上架银两(内容.数字id, 内容.编号, 内容.价格)
	elseif 序号 == 60.9 then
		self:藏宝阁购买处理(内容.数字id, 内容.编号, 内容.类型)
	elseif 序号 == 60.4 then
		self:藏宝阁取回处理(内容.数字id, 内容.编号, 内容.类型)
	elseif 序号 == 61 then
	elseif 序号 == 62 then
	elseif 序号 == 63.1 then
	elseif 序号 == 65 then
		local 数字id = 内容.数字id

		取剑会天下数据(数字id)

		local 临时数据 = 剑会天下[数字id]

		发送数据(玩家数据[数字id].连接id, 126, 临时数据)
	elseif 序号 == 66 then
		local id = 内容.数字id
		local 模式 = 内容.模式

		if 剑会天下开关 == false then
			常规提示(id, "#Y/当前不是活动时间,请在等待剑会天下开启时进行匹配！")

			return
		end

		if 玩家数据[id].角色.数据.地图数据.编号 ~= 1001 and 玩家数据[id].角色.数据.地图数据.编号 ~= 1501 and 玩家数据[id].角色.数据.地图数据.编号 ~= 1070 and 玩家数据[id].角色.数据.地图数据.编号 ~= 1092 and 玩家数据[id].角色.数据.地图数据.编号 ~= 1226 and 玩家数据[id].角色.数据.地图数据.编号 ~= 1040 then
			常规提示(id, "#Y/该场景不能进行匹配 请玩家切换场景至安全区！")

			return
		end

		if 模式 == "单人匹配" then
			if 剑会天下单人匹配开关 == false then
				常规提示(id, "#Y/单人匹配功能已经关闭！")

				return
			end

			if 玩家数据[id].角色.数据.门派 == "无门派" then
				常规提示(id, "#Y/还没有拜师呢,不能参加匹配!")

				return
			end

			if 玩家数据[id].角色.数据.等级 < 69 then
				常规提示(id, "#Y/等级不足无法加入匹配!")

				return
			end

			if 剑会记录[id] == 1 then
				常规提示(id, "#Y/已经失败过了不能参加匹配")

				return
			end

			if 取队伍人数(id) == 1 then
				剑会天下单人匹配[#剑会天下单人匹配 + 1] = {
					匹配 = true,
					id = id,
					积分 = 剑会天下[id].当前积分
				}

				发送数据(玩家数据[id].连接id, 127, {
					人数 = 内容.人数,
					模式 = 模式
				})
			else
				常规提示(id, "#Y/单人匹配模式请一个人参加活动！")

				return
			end
		elseif 模式 == "三人匹配" then
			if 剑会天下三人匹配开关 == false then
				常规提示(id, "#Y/三人匹配功能已经关闭！")

				return
			end

			if 取队长权限(id) then
				if 取队伍人数(id) == 3 then
					for i = 1, #队伍数据[玩家数据[id].队伍].成员数据 do
						if 剑会记录[队伍数据[玩家数据[id].队伍].成员数据[i]] == 1 then
							常规提示(id, "#Y/队伍中#R/" .. 玩家数据[队伍数据[玩家数据[id].队伍].成员数据[i]].角色.数据.名称 .. "#Y/玩家已经失败过了不能参加匹配~")

							return
						end

						if 玩家数据[队伍数据[玩家数据[id].队伍].成员数据[i]].角色.数据.门派 == "无门派" then
							常规提示(id, "#Y/队伍中#R/" .. 玩家数据[队伍数据[玩家数据[id].队伍].成员数据[i]].角色.数据.名称 .. "#Y/还没有拜师呢,不能参加匹配!")

							return
						end

						if 玩家数据[队伍数据[玩家数据[id].队伍].成员数据[i]].角色.数据.等级 < 69 then
							常规提示(id, "#Y/队伍中#R/" .. 玩家数据[队伍数据[玩家数据[id].队伍].成员数据[i]].角色.数据.名称 .. "#Y/等级小于69级,无法匹配三人模式")

							return
						end
					end

					local 平均分 = 0

					for i = 1, #队伍数据[玩家数据[id].队伍].成员数据 do
						取剑会天下数据(队伍数据[玩家数据[id].队伍].成员数据[i])

						平均分 = 平均分 + 剑会天下[队伍数据[玩家数据[id].队伍].成员数据[i]].当前积分

						if 玩家数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= nil then
							发送数据(玩家数据[队伍数据[玩家数据[id].队伍].成员数据[i]].连接id, 127, {
								人数 = 内容.人数,
								模式 = 模式
							})
						end
					end

					平均分 = math.floor(平均分 / 3)
					剑会天下三人匹配[#剑会天下三人匹配 + 1] = {
						匹配 = true,
						id = 玩家数据[id].队伍,
						积分 = 平均分
					}
				else
					常规提示(id, "#Y/三人匹配模式请组队并队伍人数达到三人进行活动！")

					return
				end
			else
				常规提示(id, "#Y/队长才可以发起匹配！")

				return
			end
		elseif 模式 == "五人匹配" then
			if 剑会天下五人匹配开关 == false then
				常规提示(id, "#Y/五人匹配功能已经关闭！")

				return
			end

			if 取队长权限(id) then
				if 取队伍人数(id) == 5 then
					for i = 1, #队伍数据[玩家数据[id].队伍].成员数据 do
						if 剑会记录[队伍数据[玩家数据[id].队伍].成员数据[i]] == 1 then
							常规提示(id, "#Y/队伍中#R/" .. 玩家数据[队伍数据[玩家数据[id].队伍].成员数据[i]].角色.数据.名称 .. "#Y/玩家已经失败过了不能参加匹配~")

							return
						end

						if 玩家数据[队伍数据[玩家数据[id].队伍].成员数据[i]].角色.数据.门派 == "无门派" then
							常规提示(id, "#Y/队伍中#R/" .. 玩家数据[队伍数据[玩家数据[id].队伍].成员数据[i]].角色.数据.名称 .. "#Y/还没有拜师呢,不能参加匹配!")

							return
						end

						if 玩家数据[队伍数据[玩家数据[id].队伍].成员数据[i]].角色.数据.等级 < 69 then
							常规提示(id, "#Y/队伍中#R/" .. 玩家数据[队伍数据[玩家数据[id].队伍].成员数据[i]].角色.数据.名称 .. "#Y/等级小于69级,无法匹配五人模式")

							return
						end
					end

					local 平均分 = 0

					for i = 1, #队伍数据[玩家数据[id].队伍].成员数据 do
						取剑会天下数据(队伍数据[玩家数据[id].队伍].成员数据[i])

						if 玩家数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= nil then
							发送数据(玩家数据[队伍数据[玩家数据[id].队伍].成员数据[i]].连接id, 127, {
								人数 = 内容.人数,
								模式 = 模式
							})
						end
					end

					平均分 = math.floor(平均分 / 3)
					剑会天下五人匹配[#剑会天下五人匹配 + 1] = {
						匹配 = true,
						id = 玩家数据[id].队伍,
						积分 = 平均分
					}
				else
					常规提示(id, "#Y/五人匹配模式请组队并队伍人数达到五人进行活动！")

					return
				end
			else
				常规提示(id, "#Y/队长才可以发起匹配！")

				return
			end
		end
	elseif 序号 == 67 then
		local id = 内容.数字id
		local 模式 = 内容.模式

		if 模式 == "单人匹配" then
			for n, v in pairs(剑会天下单人匹配) do
				if v.id == id then
					table.remove(剑会天下单人匹配, n)

					break
				end
			end

			发送数据(玩家数据[id].连接id, 128)
			常规提示(id, "#Y/你已经取消了匹配！")
		elseif 模式 == "三人匹配" then
			if 玩家数据[id].队伍 ~= 0 then
				for i = 1, #队伍数据[玩家数据[id].队伍].成员数据 do
					if 玩家数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= nil then
						发送数据(玩家数据[队伍数据[玩家数据[id].队伍].成员数据[i]].连接id, 128)
						常规提示(队伍数据[玩家数据[id].队伍].成员数据[i], "#Y/队伍取消了匹配！")
					end
				end

				for n, v in pairs(剑会天下三人匹配) do
					if v.id == 玩家数据[id].队伍 then
						table.remove(剑会天下三人匹配, n)

						break
					end
				end
			end
		elseif 模式 == "五人匹配" and 玩家数据[id].队伍 ~= 0 then
			for i = 1, #队伍数据[玩家数据[id].队伍].成员数据 do
				if 玩家数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= nil then
					发送数据(玩家数据[队伍数据[玩家数据[id].队伍].成员数据[i]].连接id, 128)
					常规提示(队伍数据[玩家数据[id].队伍].成员数据[i], "#Y/队伍取消了匹配！")
				end
			end

			for n, v in pairs(剑会天下五人匹配) do
				if v.id == 玩家数据[id].队伍 then
					table.remove(剑会天下五人匹配, n)

					break
				end
			end
		end
	elseif 序号 >= 75 and 序号 < 80 or 序号 >= 81 and 序号 < 88 then
		玩家数据[内容.数字id].助战:数据处理(序号, 内容)
	elseif 序号 == 80 then
		玩家数据[内容.数字id].助战:数据处理(序号, 内容)

		local id = 内容.数字id
		local 编号 = 内容.编号

		if 玩家数据[id].助战.数据[编号].助战修炼经验 == nil or 玩家数据[id].助战.数据[编号].助战修炼经验.攻击经验 >= 0 or 玩家数据[id].助战.数据[编号].助战修炼经验.法术经验 >= 0 or 玩家数据[id].助战.数据[编号].助战修炼经验.防御经验 >= 0 or 玩家数据[id].助战.数据[编号].助战修炼经验.抗法经验 >= 0 then
			玩家数据[id].助战.数据[编号].助战修炼经验 = {
				防御经验 = 0,
				法术经验 = 0,
				抗法经验 = 0,
				攻击经验 = 0
			}
		end
	elseif 序号 == 88 then
		发送数据(玩家数据[内容.数字id].连接id, 101, 玩家数据[内容.数字id].助战:取数据())
	elseif 序号 == 89 then
		local 序列 = 内容.序列
		local id = 内容.数字id

		if 玩家数据[id].角色.数据.坐骑列表[序列] == nil then
			常规提示(id, "#Y你没有这样的坐骑")

			return
		else
			玩家数据[id].角色.数据.坐骑列表[序列].名称 = 内容.名称
		end
	elseif 序号 == 90 then
		local 序列 = 内容.序列
		local id = 内容.数字id

		if 玩家数据[id].角色.数据.坐骑列表[序列] == nil then
			常规提示(id, "#Y你没有这样的坐骑")

			return
		elseif 玩家数据[id].摊位数据 ~= nil then
			常规提示(id, "#Y摆摊情况下无法进行此操作")

			return
		else
			if 玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽 == nil then
				玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽 = {}
			end

			if #玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽 >= 2 then
				常规提示(id, "#Y该坐骑已经无法统御更多的召唤兽了")

				return
			elseif 玩家数据[id].召唤兽.数据[内容.召唤兽编号] == nil then
				常规提示(id, "#Y该召唤兽不存在")

				return
			elseif 玩家数据[id].召唤兽.数据[内容.召唤兽编号].统御 ~= nil then
				local 坐骑编号 = 玩家数据[id].召唤兽.数据[内容.召唤兽编号].统御
				local BB名字 = 玩家数据[id].召唤兽.数据[内容.召唤兽编号].名称

				if 玩家数据[id].角色.数据.坐骑列表[坐骑编号] ~= nil and 玩家数据[id].角色.数据.坐骑列表[坐骑编号].统御召唤兽 ~= nil then
					local 坐骑名称 = 玩家数据[id].角色.数据.坐骑列表[玩家数据[id].召唤兽.数据[内容.召唤兽编号].统御].名称

					for i = 1, #玩家数据[id].角色.数据.坐骑列表[坐骑编号].统御召唤兽 do
						if 玩家数据[id].角色.数据.坐骑列表[坐骑编号].统御召唤兽[i] == 内容.召唤兽编号 then
							table.remove(玩家数据[id].角色.数据.坐骑列表[坐骑编号].统御召唤兽, i)
							发送数据(玩家数据[id].连接id, 61.1, {
								编号 = 坐骑编号,
								数据 = 玩家数据[id].角色.数据.坐骑列表[坐骑编号]
							})

							break
						end
					end

					常规提示(id, "#G" .. 坐骑名称 .. "#Y结束了对#R" .. BB名字 .. "#Y的统御。")
				end
			end

			玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽[#玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽 + 1] = 内容.召唤兽编号
			玩家数据[id].召唤兽.数据[内容.召唤兽编号].统御 = 序列

			统御属性刷新(id, 玩家数据[id].召唤兽.数据[内容.召唤兽编号], 玩家数据[id].角色.数据.坐骑列表[序列], 内容.召唤兽编号)

			local i = 玩家数据[id].召唤兽

			发送数据(玩家数据[id].连接id, 20, i:取存档数据(内容.召唤兽编号))
			发送数据(玩家数据[id].连接id, 61.1, {
				编号 = 序列,
				数据 = 玩家数据[id].角色.数据.坐骑列表[序列]
			})
			常规提示(id, "#Y统御召唤兽成功")
		end
	elseif 序号 == 91 then
		local 序列 = 内容.序列
		local id = 内容.数字id
		local 召唤兽编号 = 玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽[内容.编号]

		if 玩家数据[id].角色.数据.坐骑列表[序列] == nil then
			常规提示(id, "#Y你没有这样的坐骑")

			return
		elseif 玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽[内容.编号] == nil then
			常规提示(id, "#Y统御信息不存在")
		elseif 玩家数据[id].召唤兽.数据[召唤兽编号] == nil then
			table.remove(玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽, 内容.编号)
			常规提示(id, "#Y已经结束对该召唤兽的统御")
		else
			玩家数据[id].召唤兽.数据[召唤兽编号].统御 = nil
			玩家数据[id].召唤兽.数据[召唤兽编号].统御属性.力量 = 0
			玩家数据[id].召唤兽.数据[召唤兽编号].统御属性.魔力 = 0
			玩家数据[id].召唤兽.数据[召唤兽编号].统御属性.体质 = 0
			玩家数据[id].召唤兽.数据[召唤兽编号].统御属性.敏捷 = 0
			玩家数据[id].召唤兽.数据[召唤兽编号].统御属性.耐力 = 0

			玩家数据[id].召唤兽:刷新信息(召唤兽编号, "1")
			发送数据(玩家数据[id].连接id, 20, 玩家数据[id].召唤兽:取存档数据(玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽[内容.编号]))
			table.remove(玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽, 内容.编号)
			常规提示(id, "#Y已经结束对该召唤兽的统御")
		end

		发送数据(玩家数据[id].连接id, 61.1, {
			编号 = 序列,
			数据 = 玩家数据[id].角色.数据.坐骑列表[序列]
		})
	elseif 序号 == 92 then
		local 序列 = 内容.编号
		local id = 内容.数字id
		local 经验 = 5000000 * 内容.次数
		local 银子 = 10000 * 内容.次数

		if 玩家数据[id].角色.数据.坐骑列表[序列] == nil then
			常规提示(id, "#Y你没有这样的坐骑")

			return
		else
			if 取银子(id) < 银子 then
				常规提示(id, "#Y/你当前的银子好像不够哟!")

				return
			elseif 玩家数据[id].角色.数据.当前经验 < 经验 then
				常规提示(id, "#Y/你当前的经验好像不够哟!")

				return
			elseif 玩家数据[id].角色.数据.等级 <= 玩家数据[id].角色.数据.坐骑列表[序列].等级 then
				常规提示(id, "#Y/坐骑等级不能超过人物等级")

				return
			end

			玩家数据[id].角色.数据.当前经验 = 玩家数据[id].角色.数据.当前经验 - 经验

			玩家数据[id].角色:扣除银子(银子, 0, 0, "坐骑训养", 1)
			玩家数据[id].角色:坐骑喂养(序列, 经验)
		end
	elseif 序号 == 93 then
		local 序列 = 内容.编号
		local id = 内容.数字id

		if 玩家数据[id].角色.数据.坐骑列表[序列] == nil then
			常规提示(id, "#Y你没有这样的坐骑")

			return
		else
			玩家数据[id].角色:坐骑加点(序列, 内容.加点)
		end
	elseif 序号 == 94 then
		local 序列 = 内容.编号
		local id = 内容.数字id

		if 玩家数据[id].角色.数据.坐骑列表[序列] == nil then
			常规提示(id, "#Y你没有这样的坐骑")

			return
		elseif 取银子(id) < 100000 then
			常规提示(id, "#Y/你当前的银子好像不够哟!")

			return
		else
			玩家数据[id].角色:扣除银子(100000, 0, 0, "坐骑洗点", 1)
			玩家数据[id].角色:坐骑洗点(序列)
		end
	elseif 序号 == 95 then
		local 序列 = 内容.编号
		local id = 内容.数字id

		if 玩家数据[id].角色.数据.坐骑列表[序列] == nil then
			常规提示(id, "#Y你没有这样的坐骑")

			return
		else
			玩家数据[id].角色:坐骑放生(序列)
		end
	elseif 序号 == 96 then
		local 序列 = 内容.编号
		local id = 内容.数字id

		for i = 1, #玩家数据[id].角色.数据.坐骑列表 do
			if 玩家数据[id].角色.数据.坐骑列表[i].技能点 == nil then
				玩家数据[id].角色.数据.坐骑列表[i].技能点 = 0
			end
		end

		发送数据(玩家数据[id].连接id, 61.2, 玩家数据[id].角色.数据.坐骑列表)
	elseif 序号 == 97 then
		local 序列 = 内容.编号
		local id = 内容.数字id

		if 玩家数据[id].角色.数据.坐骑列表[序列] == nil then
			常规提示(id, "#Y你没有这样的坐骑")

			return
		elseif 取银子(id) < 1000 then
			常规提示(id, "#Y/你当前的银子好像不够哟!")

			return
		else
			玩家数据[id].角色:扣除银子(1000, 0, 0, "坐骑喂养", 1)

			玩家数据[id].角色.数据.坐骑列表[序列].忠诚 = 10000

			玩家数据[id].角色:坐骑刷新(序列)
		end
	elseif 序号 == 98 then
		local 序列 = 内容.编号
		local id = 内容.数字id

		if 玩家数据[id].角色.数据.坐骑列表[序列] == nil then
			常规提示(id, "#Y你没有这样的坐骑")

			return
		elseif 玩家数据[id].角色.数据.坐骑列表[序列].技能点 < 1 then
			常规提示(id, "#Y你没有足够的技能点")

			return
		else
			local 编号 = 内容.技能编号
			local 技能名称 = 内容.名称

			if 玩家数据[id].角色.数据.坐骑列表[序列].技能[编号] ~= nil and 玩家数据[id].角色.数据.坐骑列表[序列].技能[编号] == 技能名称 then
				if 玩家数据[id].角色.数据.坐骑列表[序列].技能等级 == nil then
					玩家数据[id].角色.数据.坐骑列表[序列].技能等级 = {}
				end

				if 玩家数据[id].角色.数据.坐骑列表[序列].技能等级[编号] == nil then
					玩家数据[id].角色.数据.坐骑列表[序列].技能等级[编号] = 1
					玩家数据[id].角色.数据.坐骑列表[序列].技能点 = 玩家数据[id].角色.数据.坐骑列表[序列].技能点 - 1

					发送数据(玩家数据[id].连接id, 61.1, {
						编号 = 序列,
						数据 = 玩家数据[id].角色.数据.坐骑列表[序列]
					})
				elseif 玩家数据[id].角色.数据.坐骑列表[序列].技能等级[编号] >= 3 then
					常规提示(id, "#Y该技能以及升到顶级")

					return
				else
					玩家数据[id].角色.数据.坐骑列表[序列].技能等级[编号] = 玩家数据[id].角色.数据.坐骑列表[序列].技能等级[编号] + 1
					玩家数据[id].角色.数据.坐骑列表[序列].技能点 = 玩家数据[id].角色.数据.坐骑列表[序列].技能点 - 1

					if 玩家数据[id].角色.数据.坐骑列表[序列].技能等级[编号] >= 3 then
						local 特殊1 = {
							"雷击",
							"落岩",
							"水攻",
							"烈火"
						}
						local 特殊2 = {
							"奔雷咒",
							"泰山压顶",
							"水漫金山",
							"地狱烈火"
						}

						if 取列表中是否存在内容(特殊1, 技能名称) == true then
							for i = 1, #特殊1 do
								if 特殊1[i] == 技能名称 then
									玩家数据[id].角色.数据.坐骑列表[序列].技能[编号] = 特殊2[i]

									break
								end
							end
						elseif string.find(技能名称, "【伪】") then
							玩家数据[id].角色.数据.坐骑列表[序列].技能[编号] = string.gsub(技能名称, "【伪】", "")
						else
							玩家数据[id].角色.数据.坐骑列表[序列].技能[编号] = "高级" .. 技能名称
						end

						常规提示(id, "#Y技能升级成功")
					end

					发送数据(玩家数据[id].连接id, 61.1, {
						编号 = 序列,
						数据 = 玩家数据[id].角色.数据.坐骑列表[序列]
					})
				end
			end
		end
	elseif 序号 == 99 then
		炼丹查看[内容.数字id] = nil
	elseif 序号 == 99.1 then
		游戏活动类:炼丹下注(内容)
	elseif 序号 == 100 then
		self:内充处理(内容)
	elseif 序号 == 100.3 then
		local id = 内容.数字id
		local 消耗数额 = math.ceil(内容.数额 / 兑换比例)
		local 点卡 = f函数.读配置(程序目录 .. "data\\" .. 玩家数据[id].账号 .. "\\账号信息.txt", "账号配置", "点卡") + 0
		local 之前 = 点卡

		if 点卡 < 消耗数额 then
			常规提示(id, "#Y你没有这么多的点卡可以使用！")

			return
		else
			常规提示(id, "#Y兑换仙玉成功！")

			点卡 = 点卡 - 消耗数额

			f函数.写配置(程序目录 .. "data\\" .. 玩家数据[id].账号 .. "\\账号信息.txt", "账号配置", "点卡", 点卡)

			local 日志 = 读入文件("data\\" .. 玩家数据[id].账号 .. "\\消费记录.txt")
			日志 = 日志 .. "\n" .. 时间转换(os.time()) .. format("。以下为具体扣费信息：扣除数额为%s点点卡，扣除之前点卡数额为%s点，扣除之后剩余点卡%s点。本次操作的角色id为%s#分割符\n", 消耗数额, 之前, 点卡, id)

			写出文件("data\\" .. 玩家数据[id].账号 .. "\\消费记录.txt", 日志)
			添加仙玉(内容.数额, 玩家数据[id].账号, id, "点卡兑换")
			发送数据(玩家数据[id].连接id, 92.1, {
				点卡 = 点卡
			})
		end
	elseif 序号 == 101 then
		local id = 内容.数字id
		local 任务id = 玩家数据[id].角色:取任务(7758)

		if 任务id == 0 then
			常规提示(id, "#Y/你没有这样的任务")

			return
		elseif 检查格子(id) == false then
			常规提示(id, "#Y/你身上没有足够的空间")

			return
		end

		local 类型 = 内容.类型

		if 类型 == 1 or 类型 == 2 or 类型 == 3 then
			local 星级 = 任务数据[任务id].星级

			if 类型 == 3 then
				local a = 1

				for i = 1, #通用特技 do
					if 内容.数据 == 通用特技[i] then
						a = 2
					end
				end

				if a == 1 then
					常规提示(id, "#Y/请检查输入的特技是否正确")

					return
				end
			elseif 类型 == 2 then
				if (内容.数据 == "愤怒" or 内容.数据 == "暴怒") and 任务数据[任务id].序列 ~= 22 then
					常规提示(id, "#Y/暴怒和愤怒只能给腰带使用")

					return
				end
			elseif 类型 == 1 then
				if 内容.双加1 == 内容.双加2 then
					常规提示(id, "#Y/双加属性不能相同")

					return
				elseif 任务数据[任务id].序列 ~= 21 and 任务数据[任务id].序列 > 18 then
					常规提示(id, "#Y/双加只有武器和衣服可以指定")

					return
				end
			end

			if 玩家数据[id].角色:扣除仙玉((星级 + 1) * 10000, "指定系统", id) then
				if 类型 == 1 then
					任务数据[任务id].指定.双加 = {
						内容.双加1,
						内容.双加2
					}
				elseif 类型 == 2 then
					任务数据[任务id].指定.特效 = 内容.数据
				elseif 类型 == 3 then
					任务数据[任务id].指定.特技 = 内容.数据
				end

				常规提示(id, "#Y/指定数据成功")
			else
				常规提示(id, "#Y/你没有这么多的仙玉")
			end
		elseif 类型 == 4 then
			玩家数据[id].装备:添加熔合装备属性(id, 任务id)
		end
	elseif 序号 == 103 then
		local id = 内容.数字id
		local 信息 = 取随机数(1, 5)

		发送数据(玩家数据[id].连接id, 132, 信息)
	elseif 序号 == 103.1 then
		local id = 内容.数字id

		if 玩家数据[id].角色.数据.飞行时间限制 == nil then
			玩家数据[id].角色.数据.飞行时间限制 = os.time()
		end

		if 玩家数据[id].道具:取飞行限制(id) == false then
			local aa = true

			if (玩家数据[id].角色.数据.月卡传送 or 0) >= 10 then
				aa = 是否月卡用户(id)
				玩家数据[id].角色.数据.月卡传送 = 0
			end

			if 玩家数据[id].角色.数据.月卡激活 > 0 and aa then
				玩家数据[id].角色.数据.月卡传送 = (玩家数据[id].角色.数据.月卡传送 or 0) + 1

				地图处理类:跳转地图(id, 内容[1], 内容[2], 内容[3])
				常规提示(id, "#Y/VIP月卡传送成功！")

				return
			elseif 内容[4] ~= nil and 内容[4] == "任务" then
				常规提示(id, "#Y很抱歉、只有月卡用户才能使用#R/任务快捷传送#Y功能！")

				return
			elseif 银子检查(id, 20000) then
				玩家数据[id].角色:扣除银子(20000, 0, 0, "快捷传送", 1)
				地图处理类:跳转地图(id, 内容[1], 内容[2], 内容[3])
				常规提示(id, "#Y/快捷传送成功！")

				return
			else
				常规提示(id, "#Y/传送失败、你的银两不足#R20000")

				return
			end
		end
	elseif 序号 == 104 then
		local id = 内容.数字id

		if 玩家数据[id].角色.数据.月卡激活 == nil then
			玩家数据[id].角色.数据.月卡激活 = 0
		end

		发送数据(玩家数据[id].连接id, 133, {
			月卡激活 = 玩家数据[id].角色.数据.月卡激活,
			到期时间 = 玩家数据[id].角色.数据.飞行时间限制,
			点卡 = 取点卡数据(id)
		})
	elseif 序号 == 104.1 then
		local id = 内容.数字id

		if 活动次数查询(id, "每日月卡奖励") == false then
			return
		end

		if 玩家数据[id].角色.数据.飞行时间限制 == nil then
			玩家数据[id].角色.数据.飞行时间限制 = os.time()
		end

		if os.time() < 玩家数据[id].角色.数据.飞行时间限制 then
			添加活动次数(id, "每日月卡奖励")
			玩家数据[id].角色:添加银子(100000, "月卡", 1)
			玩家数据[id].角色:添加经验(1000000, "月卡", 1)
			玩家数据[id].道具:给予书铁(id, {
				9,
				11
			}, "精铁")
			玩家数据[id].道具:给予书铁(id, {
				9,
				11
			}, "指南书")
			常规提示(id, "#Y/你获得了#G[90-110级书铁]#")
			快捷给道具(id, "高级魔兽要诀", 1)
			快捷给道具(id, "通灵重置丹", 1)
			快捷给道具(id, "通灵神臂", 1)
			快捷给道具(id, "高级通灵重置丹", 1)
			快捷给道具(id, "通灵神符", 1)
			快捷给道具(id, "超级通灵重置丹", 1)
			快捷给道具(id, "高级藏宝图", 1)
			快捷给道具(id, "藏宝图", 1)
			快捷给道具(id, "属性转换符", 1)
			快捷给道具(id, "百炼晶石碎片", 1)
			快捷给道具(id, "金柳露", 10)
			快捷给道具(id, "超级金柳露", 2)
		else
			常规提示(id, "#Y/你不是尊贵的月卡用户，无法领取")
		end
	elseif 序号 == 105.1 then
		local id = 内容.数字id

		if 活动次数查询(id, "月卡师门奖励") == false then
			return
		end

		if 玩家数据[id].角色.数据.飞行时间限制 == nil then
			玩家数据[id].角色.数据.飞行时间限制 = os.time()
		end

		if os.time() < 玩家数据[id].角色.数据.飞行时间限制 then
			添加活动次数(id, "月卡师门奖励")
			玩家数据[id].角色:添加银子(100000, "月卡", 1)
			玩家数据[id].角色:添加经验(100000, "月卡", 1)
			玩家数据[id].道具:给予书铁(id, {
				10,
				11
			}, "精铁")
			玩家数据[id].道具:给予书铁(id, {
				10,
				11
			}, "指南书")
			常规提示(id, "#Y/你获得了#G[100-110级书铁]#")
		else
			常规提示(id, "#Y/你不是尊贵的月卡用户，无法领取")
		end
	elseif 序号 == 105.21 then
		local id = 内容.数字id

		if 是否月卡用户(id) == false then
			常规提示(id, "很抱歉，你不是月卡用户，无法使用该功能。")

			return
		end

		if 活动次数查询(id, "自动捉鬼") == false then
			if 玩家数据[id].角色.数据.自动捉鬼 == true then
				玩家数据[id].角色.数据.自动捉鬼 = false

				发送数据(玩家数据[id].连接id, 48.1, {
					自动捉鬼 = 玩家数据[id].角色.数据.自动捉鬼
				})
			end

			return
		end

		取消其他自动(id, "捉鬼")

		if 玩家数据[id].角色.数据.自动捉鬼 then
			玩家数据[id].角色.数据.自动捉鬼 = false

			常规提示(id, "#Y/你关闭了自动捉鬼功能")

			自动捉鬼[id] = nil
		else
			if 玩家数据[id].队伍 == nil or 玩家数据[id].队伍 == 0 then
				常规提示(id, "#Y/请先组队！")

				return
			end

			if 取队伍人数(id) < 3 then
				常规提示(id, "#Y/队伍人数不足三人，无法使用此功能！")

				return
			end

			玩家数据[id].角色.数据.自动捉鬼 = true

			常规提示(id, "#Y你正在使用自动捉鬼功能\n#R每隔" .. 服务端参数.自动捉鬼时间 .. "秒#W会自动捉鬼战斗\n如需关闭此功能#G再次点击即可关闭此功能")

			自动捉鬼[id] = os.time()
		end

		发送数据(玩家数据[id].连接id, 48.1, {
			自动捉鬼 = 玩家数据[id].角色.数据.自动捉鬼
		})
	elseif 序号 == 105.2 then
		local id = 内容.数字id

		if 活动次数查询(id, "月卡抓鬼奖励") == false then
			return
		end

		if 玩家数据[id].角色.数据.飞行时间限制 == nil then
			玩家数据[id].角色.数据.飞行时间限制 = os.time()
		end

		if os.time() < 玩家数据[id].角色.数据.飞行时间限制 then
			添加活动次数(id, "月卡抓鬼奖励")
			玩家数据[id].角色:添加银子(100000, "月卡", 1)
			玩家数据[id].角色:添加经验(100000, "月卡", 1)
			玩家数据[id].道具:给予书铁(id, {
				10,
				11
			}, "精铁")
			玩家数据[id].道具:给予书铁(id, {
				10,
				11
			}, "指南书")
			常规提示(id, "#Y/你获得了#G[100-110级书铁]#")
		else
			常规提示(id, "#Y/你不是尊贵的月卡用户，无法领取")
		end
	elseif 序号 == 105.3 then
		local id = 内容.数字id

		if 活动次数查询(id, "月卡押镖奖励") == false then
			return
		end

		if 玩家数据[id].角色.数据.飞行时间限制 == nil then
			玩家数据[id].角色.数据.飞行时间限制 = os.time()
		end

		if os.time() < 玩家数据[id].角色.数据.飞行时间限制 then
			添加活动次数(id, "月卡押镖奖励")
			玩家数据[id].角色:添加银子(100000, "月卡", 1)
			玩家数据[id].角色:添加经验(100000, "月卡", 1)
			玩家数据[id].道具:给予道具(id, "灵饰指南书", {
				8,
				10
			})
			玩家数据[id].道具:给予道具(id, "元灵晶石", {
				8,
				10
			})
			常规提示(id, "#Y/你获得了#G[80-100级灵饰书铁]#")
		else
			常规提示(id, "#Y/你不是尊贵的月卡用户，无法领取")
		end
	elseif 序号 == 105.4 then
		local id = 内容.数字id

		if 活动次数查询(id, "月卡官职奖励") == false then
			return
		end

		if 玩家数据[id].角色.数据.飞行时间限制 == nil then
			玩家数据[id].角色.数据.飞行时间限制 = os.time()
		end

		if os.time() < 玩家数据[id].角色.数据.飞行时间限制 then
			添加活动次数(id, "月卡官职奖励")
			玩家数据[id].角色:添加银子(100000, "月卡", 1)
			玩家数据[id].角色:添加经验(100000, "月卡", 1)
			玩家数据[id].道具:给予道具(id, "灵饰指南书", {
				8,
				10
			})
			玩家数据[id].道具:给予道具(id, "元灵晶石", {
				8,
				10
			})
			常规提示(id, "#Y/你获得了#G[80-100级灵饰书铁]#")
		else
			常规提示(id, "#Y/你不是尊贵的月卡用户，无法领取")
		end
	elseif 序号 == 105.5 then
		local id = 内容.数字id

		if 是否月卡用户(id) == false then
			常规提示(id, "很抱歉，你不是月卡用户，无法使用该功能。")

			return
		end

		if not 银子检查(id, 一键附魔金钱 * 10000) then
			常规提示(id, "#y/您身上银子不足#R" .. 一键附魔金钱 .. "#YW,无法附魔")

			return
		end

		助战附魔 = false

		玩家数据[id].道具:一键附魔处理(id, 玩家数据[id].角色.数据, nil, true)

		if 助战附魔 == false then
			return
		end

		for i = 1, #玩家数据[id].助战.数据 do
			玩家数据[id].道具:一键附魔处理(id, 玩家数据[id].助战.数据[i], i, false)
		end
	elseif 序号 == 105.7 then
		local id = 内容.数字id

		if 是否月卡用户(id) == false then
			常规提示(id, "很抱歉，你不是月卡用户，无法使用该功能。")

			return
		end

		if 玩家数据[id].角色.数据.战斗速度 == nil then
			玩家数据[id].角色.数据.战斗速度 = 1
		end

		玩家数据[id].角色.数据.战斗速度 = 玩家数据[id].角色.数据.战斗速度 + 1
		local aa = 0

		if 管理账号列表[玩家数据[id].账号] ~= nil then
			aa = math.max(4 - 最大战斗速度, 0)
		end

		if 玩家数据[id].角色.数据.战斗速度 > 最大战斗速度 + aa then
			玩家数据[id].角色.数据.战斗速度 = 1
		end

		发送数据(玩家数据[id].连接id, 133.3, 玩家数据[id].角色.数据.战斗速度)
		常规提示(id, "当前战斗速度调整为第【#R" .. 个位数字转汉字(玩家数据[id].角色.数据.战斗速度) .. "#Y】档")
	elseif 序号 == 105.6 then
		local id = 内容.数字id

		if 是否月卡用户(id) == false then
			常规提示(id, "很抱歉，你不是月卡用户，无法使用该功能。")

			return
		end

		if 玩家数据[id].角色.数据.移速加成 == nil then
			玩家数据[id].角色.数据.移速加成 = false
		end

		玩家数据[id].角色.数据.移速加成 = not 玩家数据[id].角色.数据.移速加成

		地图处理类:玩家是否加速(id, 玩家数据[id].角色.数据.移速加成)

		if 玩家数据[id].角色.数据.移速加成 then
			常规提示(id, "你#R开启#Y了月卡专属#P移速加成")
		else
			常规提示(id, "你#R关闭#Y了月卡专属#P移速加成。")
		end
	elseif 序号 == 104.2 then
		local id = 内容.数字id

		if 玩家数据[id].角色.数据.月卡激活 ~= nil and 玩家数据[id].角色.数据.月卡激活 >= 1 then
			return 常规提示(id, "您当前的月卡还未过期")
		else
			local 点卡 = f函数.读配置(程序目录 .. "data\\" .. 玩家数据[id].账号 .. "\\账号信息.txt", "账号配置", "点卡") + 0
			local 消耗点卡 = 500
			local 开通月卡 = false

			if 单机设置 then
				开通月卡 = true
			elseif 玩家数据[id].角色:扣除点卡(消耗点卡, "购买月卡", id) == false then
				return 常规提示(id, "激活月卡需要" .. 消耗点卡 .. "点卡")
			else
				开通月卡 = true
			end

			if 开通月卡 == true then
				玩家数据[id].角色.数据.月卡激活 = 1
				玩家数据[id].角色.数据.月卡领取 = 30
				玩家数据[id].角色.数据.飞行时间限制 = os.time() + 2592000

				发送数据(玩家数据[id].连接id, 133, {
					月卡激活 = 玩家数据[id].角色.数据.月卡激活,
					到期时间 = 玩家数据[id].角色.数据.飞行时间限制,
					点卡 = 取点卡数据(id)
				})

				return 常规提示(id, "恭喜您成功激活了月卡")
			end
		end
	elseif 序号 == 105 then
		local id = 内容.数字id

		发送数据(玩家数据[id].连接id, 134, 玩家数据[id].角色.数据.银子)
	elseif 序号 == 115.1 then
		local id = 内容.数字id
		local 充值比例 = 1

		if 玩家数据[id].角色.数据.银子 >= 300 then
			充值比例 = 1
			玩家数据[id].角色.数据.元宝.充值比例 = 充值比例
		elseif 玩家数据[id].角色.数据.银子 >= 500 then
			充值比例 = 1
			玩家数据[id].角色.数据.元宝.充值比例 = 充值比例
		elseif 玩家数据[id].角色.数据.银子 >= 800 then
			充值比例 = 1
			玩家数据[id].角色.数据.元宝.充值比例 = 充值比例
		elseif 玩家数据[id].角色.数据.银子 >= 1000 then
			充值比例 = 1
			玩家数据[id].角色.数据.元宝.充值比例 = 充值比例
		elseif 玩家数据[id].角色.数据.银子 >= 1200 then
			充值比例 = 1
			玩家数据[id].角色.数据.元宝.充值比例 = 充值比例
		elseif 玩家数据[id].角色.数据.银子 >= 1300 then
			充值比例 = 1
			玩家数据[id].角色.数据.元宝.充值比例 = 充值比例
		elseif 玩家数据[id].角色.数据.银子 >= 1400 then
			充值比例 = 1
			玩家数据[id].角色.数据.元宝.充值比例 = 充值比例
		elseif 玩家数据[id].角色.数据.银子 >= 1500 then
			充值比例 = 1
			玩家数据[id].角色.数据.元宝.充值比例 = 充值比例
		elseif 玩家数据[id].角色.数据.银子 >= 1600 then
			充值比例 = 1
			玩家数据[id].角色.数据.元宝.充值比例 = 充值比例
		elseif 玩家数据[id].角色.数据.银子 >= 1700 then
			充值比例 = 1
			玩家数据[id].角色.数据.元宝.充值比例 = 充值比例
		elseif 玩家数据[id].角色.数据.银子 >= 1800 then
			充值比例 = 1
			玩家数据[id].角色.数据.元宝.充值比例 = 充值比例
		elseif 玩家数据[id].角色.数据.银子 >= 1900 then
			充值比例 = 1
			玩家数据[id].角色.数据.元宝.充值比例 = 充值比例
		elseif 玩家数据[id].角色.数据.银子 >= 2000 then
			充值比例 = 1
			玩家数据[id].角色.数据.元宝.充值比例 = 充值比例
		elseif 玩家数据[id].角色.数据.银子 >= 2100 then
			充值比例 = 1
			玩家数据[id].角色.数据.元宝.充值比例 = 充值比例
		elseif 玩家数据[id].角色.数据.银子 >= 2200 then
			充值比例 = 1
			玩家数据[id].角色.数据.元宝.充值比例 = 充值比例
		elseif 玩家数据[id].角色.数据.银子 >= 2300 then
			充值比例 = 1
			玩家数据[id].角色.数据.元宝.充值比例 = 充值比例
		elseif 玩家数据[id].角色.数据.银子 >= 2400 then
			充值比例 = 1
			玩家数据[id].角色.数据.元宝.充值比例 = 充值比例
		elseif 玩家数据[id].角色.数据.银子 >= 2500 then
			充值比例 = 1
			玩家数据[id].角色.数据.元宝.充值比例 = 充值比例
		end

		发送数据(玩家数据[id].连接id, 134.1, 玩家数据[id].角色.数据.元宝)
	elseif 序号 == 116 then
		local id = 内容.数字id

		玩家数据[id].道具:一键出售处理(连接id, id)
	elseif 序号 == 115.2 then
		local id = 内容.数字id
		local 序列 = 内容.序列

		if 序列 == 3 then
			if 玩家数据[id].角色.数据.银子 < 300 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.银子 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end

			累冲金额总计(90, 玩家数据[id].账号, id, "累冲信息")

			玩家数据[id].角色.数据.银子 = 1
			玩家数据[id].角色.数据.银子 = 玩家数据[id].角色.数据.银子 + 500

			常规提示(id, "恭喜你，领取 【500】元宝")
		elseif 序列 == 4 then
			if 玩家数据[id].角色.数据.银子 < 500 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.元宝.累积500 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end

			玩家数据[id].角色.数据.元宝.累积500 = 1
			玩家数据[id].角色.数据.元宝.当前元宝 = 玩家数据[id].角色.数据.元宝.当前元宝 + 1000

			玩家数据[id].召唤兽:添加召唤兽("VIP·大棚王", nil, nil, true, 0, 内容.物法)
			常规提示(id, "恭喜你，领取 1000元宝以及【VIP·大棚王】宠物")
		elseif 序列 == 5 then
			if 玩家数据[id].角色.数据.银子 < 800 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.元宝.累积800 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end

			玩家数据[id].角色.数据.元宝.累积800 = 1
			玩家数据[id].角色.数据.元宝.当前元宝 = 玩家数据[id].角色.数据.元宝.当前元宝 + 1500

			玩家数据[id].召唤兽:添加召唤兽("VIP·超级鲲鹏", nil, nil, true, 0, 内容.物法)
			玩家数据[id].道具:给予道具(id, "高级魔兽要诀", nil, "扶摇万里")
			常规提示(id, "恭喜你，领取 1500元宝以及【VIP·超级鲲鹏】宠物 和【扶摇万里】技能书")
		elseif 序列 == 6 then
			if 玩家数据[id].角色.数据.银子 < 1000 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.元宝.累积1000 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end

			玩家数据[id].角色.数据.元宝.累积1000 = 1
			玩家数据[id].角色.数据.元宝.当前元宝 = 玩家数据[id].角色.数据.元宝.当前元宝 + 2000

			玩家数据[id].召唤兽:添加召唤兽("VIP·齐天大圣", nil, nil, true, 0, 内容.物法)
			常规提示(id, "恭喜你，领取 2000元宝以及 【VIP·齐天大圣】宠物")
		elseif 序列 == 7 then
			if 玩家数据[id].角色.数据.银子 < 1200 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.元宝.累积1200 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end

			玩家数据[id].角色.数据.元宝.累积1200 = 1
			玩家数据[id].角色.数据.元宝.当前元宝 = 玩家数据[id].角色.数据.元宝.当前元宝 + 2200

			玩家数据[id].道具:给予道具(id, "洗魂符", 99, true)
			玩家数据[id].道具:给予道具(id, "神级·魂环", 1, "魂环")
			常规提示(id, "恭喜你，领取 2200元宝以及 【神级·魂环】和999个洗魂符")
		elseif 序列 == 8 then
			if 玩家数据[id].角色.数据.银子 < 1300 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.元宝.累积1300 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end

			玩家数据[id].角色.数据.元宝.累积1300 = 1
			玩家数据[id].角色.数据.元宝.当前元宝 = 玩家数据[id].角色.数据.元宝.当前元宝 + 2300

			玩家数据[id].道具:给予道具(id, "洗骨符", 99, true)
			玩家数据[id].道具:给予道具(id, "神级·魂骨", 1, "魂骨")
			常规提示(id, "恭喜你，领取 2300元宝以及  【神级·魂骨】和999个洗骨符")
		elseif 序列 == 9 then
			if 玩家数据[id].角色.数据.银子 < 1400 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.元宝.累积1400 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end

			玩家数据[id].角色.数据.元宝.累积1400 = 1
			玩家数据[id].角色.数据.元宝.当前元宝 = 玩家数据[id].角色.数据.元宝.当前元宝 + 2400

			常规提示(id, "恭喜你，领取 2400元宝")
		elseif 序列 == 10 then
			if 玩家数据[id].角色.数据.银子 < 1500 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.元宝.累积1500 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end

			玩家数据[id].角色.数据.元宝.累积1500 = 1
			玩家数据[id].角色.数据.元宝.当前元宝 = 玩家数据[id].角色.数据.元宝.当前元宝 + 2500

			常规提示(id, "恭喜你，领取 2500元宝")
		elseif 序列 == 11 then
			if 玩家数据[id].角色.数据.银子 < 1600 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.元宝.累积1600 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end

			玩家数据[id].角色.数据.元宝.累积1600 = 1
			玩家数据[id].角色.数据.元宝.当前元宝 = 玩家数据[id].角色.数据.元宝.当前元宝 + 2600

			玩家数据[id].召唤兽:添加召唤兽("VIP·蓝灵独角兽", nil, nil, true, 0, 内容.物法)
			常规提示(id, "恭喜你，领取 2600元宝以及 【VIP·蓝灵独角兽】宠物")
		elseif 序列 == 12 then
			if 玩家数据[id].角色.数据.银子 < 1700 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.元宝.累积1700 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end

			玩家数据[id].角色.数据.元宝.累积1700 = 1
			玩家数据[id].角色.数据.元宝.当前元宝 = 玩家数据[id].角色.数据.元宝.当前元宝 + 2700

			常规提示(id, "恭喜你，领取 2700元宝")
		elseif 序列 == 13 then
			if 玩家数据[id].角色.数据.银子 < 1800 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.元宝.累积1800 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end

			玩家数据[id].角色.数据.元宝.累积1800 = 1
			玩家数据[id].角色.数据.元宝.当前元宝 = 玩家数据[id].角色.数据.元宝.当前元宝 + 2800

			常规提示(id, "恭喜你，领取 2800元宝")
		elseif 序列 == 14 then
			if 玩家数据[id].角色.数据.银子 < 1900 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.元宝.累积1900 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end

			玩家数据[id].角色.数据.元宝.累积1900 = 1
			玩家数据[id].角色.数据.元宝.当前元宝 = 玩家数据[id].角色.数据.元宝.当前元宝 + 2900

			常规提示(id, "恭喜你，领取 2900元宝")
		elseif 序列 == 15 then
			if 玩家数据[id].角色.数据.银子 < 2000 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.元宝.累积2000 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end

			玩家数据[id].角色.数据.元宝.累积2000 = 1
			玩家数据[id].角色.数据.元宝.当前元宝 = 玩家数据[id].角色.数据.元宝.当前元宝 + 3000

			常规提示(id, "恭喜你，领取 3000元宝")
		elseif 序列 == 16 then
			if 玩家数据[id].角色.数据.银子 < 2100 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.元宝.累积2100 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end

			玩家数据[id].角色.数据.元宝.累积2100 = 1
			玩家数据[id].角色.数据.元宝.当前元宝 = 玩家数据[id].角色.数据.元宝.当前元宝 + 3100

			常规提示(id, "恭喜你，领取 3100元宝")
		elseif 序列 == 17 then
			if 玩家数据[id].角色.数据.银子 < 2200 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.元宝.累积2200 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end

			玩家数据[id].角色.数据.元宝.累积2200 = 1
			玩家数据[id].角色.数据.元宝.当前元宝 = 玩家数据[id].角色.数据.元宝.当前元宝 + 3200

			常规提示(id, "恭喜你，领取 3200元宝")
		elseif 序列 == 18 then
			if 玩家数据[id].角色.数据.银子 < 2300 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.元宝.累积2300 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end

			玩家数据[id].角色.数据.元宝.累积2300 = 1
			玩家数据[id].角色.数据.元宝.当前元宝 = 玩家数据[id].角色.数据.元宝.当前元宝 + 3300

			常规提示(id, "恭喜你，领取 3300元宝累积奖励 快去找GM定制专属高级宠物吧!")
		elseif 序列 == 19 then
			if 玩家数据[id].角色.数据.银子 < 2400 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.元宝.累积2400 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end

			玩家数据[id].角色.数据.元宝.累积2400 = 1
			玩家数据[id].角色.数据.元宝.当前元宝 = 玩家数据[id].角色.数据.元宝.当前元宝 + 3400

			常规提示(id, "恭喜你，领取 3400元宝累积奖励 快去找GM定制专属高级灵饰吧!")
		elseif 序列 == 20 then
			if 玩家数据[id].角色.数据.银子 < 2500 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.银子 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end

			玩家数据[id].角色.数据.银子 = 1

			常规提示(id, "恭喜你，领取 3500元宝累积奖励 快去找GM定制专属高级装备吧!")
		elseif 序列 == 2 then
			if 玩家数据[id].角色.数据.银子 < 100 then
				常规提示(id, "充值的金额不足以领取该奖励")

				return
			end

			if 玩家数据[id].角色.数据.银子 == 1 then
				常规提示(id, "您已经领取服此奖励，无法重复领取")

				return
			end
		end
	elseif 序号 == 106.2 then
		local id = 内容.数字id
		local 传送选中 = 0

		if 内容.选中 == 4 then
			地图处理类:跳转地图(id, 1111, 175, 122)
		elseif 内容.选中 == 5 then
			地图处理类:跳转地图(id, 1140, 20, 18)
		elseif 内容.选中 == 6 then
			地图处理类:跳转地图(id, 1116, 71, 77)
		elseif 内容.选中 == 7 then
			地图处理类:跳转地图(id, 1150, 40, 63)
		elseif 内容.选中 == 8 then
			地图处理类:跳转地图(id, 1251, 90, 41)
		end
	elseif 序号 == 106.3 then
		local id = 内容.数字id
		local 传送选中 = 0

		if 内容.选中 == 4 then
			地图处理类:跳转地图(id, 1131, 111, 79)
		elseif 内容.选中 == 5 then
			地图处理类:跳转地图(id, 1512, 77, 29)
		elseif 内容.选中 == 6 then
			地图处理类:跳转地图(id, 1122, 102, 98)
		elseif 内容.选中 == 7 then
			地图处理类:跳转地图(id, 1139, 68, 124)
		elseif 内容.选中 == 8 then
			地图处理类:跳转地图(id, 1249, 74, 37)
		end
	elseif 序号 == 106.4 then
		local id = 内容.数字id
		local 传送选中 = 0

		if 内容.选中 == 4 then
			地图处理类:跳转地图(id, 1198, 130, 83)
		elseif 内容.选中 == 5 then
			地图处理类:跳转地图(id, 1002, 9, 88)
		elseif 内容.选中 == 6 then
			地图处理类:跳转地图(id, 1135, 72, 63)
		elseif 内容.选中 == 7 then
			地图处理类:跳转地图(id, 1138, 46, 121)
		elseif 内容.选中 == 8 then
			地图处理类:跳转地图(id, 1250, 70, 93)
		end
	elseif 序号 == 107.1 then
		local id = 内容.数字id
		local 仙玉 = f函数.读配置(程序目录 .. "data\\" .. 玩家数据[id].账号 .. "\\账号信息.txt", "账号配置", "仙玉")

		发送数据(玩家数据[id].连接id, 59.2, 仙玉)
	elseif 序号 == 111 then
		local id = 内容.数字id
		local 仙玉 = f函数.读配置(程序目录 .. "data\\" .. 玩家数据[id].账号 .. "\\账号信息.txt", "账号配置", "仙玉") + 0
		local 消耗仙玉 = 1000

		if 仙玉 < 消耗仙玉 then
			常规提示(id, "#Y/你没有那么多的仙玉")
		else
			玩家数据[id].角色:扣除仙玉(消耗仙玉, "购买传音", id)

			local 名称 = "传音纸鹤"

			玩家数据[id].道具:给予道具(id, 名称, 1)
			常规提示(id, "#Y/你获得了" .. 名称)
		end
	elseif 序号 == 108 then
		self:封号处理(id, 序号, 内容)
	elseif 序号 == 200 then
		local id = 内容.数字id + 0

		if 图鉴系统[id] == nil then
			图鉴系统[id] = {
				东海湾 = {
					激活 = 100,
					海星 = 0,
					巨蛙 = 0,
					大海龟 = 0,
					海毛虫 = 0,
					章鱼 = 0
				},
				江南野外 = {
					野猪 = 0,
					树怪 = 0,
					狸 = 0,
					激活 = 100
				},
				大雁塔 = {
					激活 = 100,
					骷髅怪 = 0,
					强盗 = 0,
					大蝙蝠 = 0,
					蛤蟆精 = 0,
					羊头怪 = 0,
					花妖 = 0,
					狐狸精 = 0,
					赌徒 = 0
				},
				大唐国境 = {
					护卫 = 0,
					山贼 = 0,
					强盗 = 0,
					激活 = 100,
					赌徒 = 0
				},
				大唐境外 = {
					激活 = 100,
					花妖 = 0,
					老虎 = 0,
					黑熊 = 0
				},
				魔王寨 = {
					激活 = 100,
					牛妖 = 0,
					蛤蟆精 = 0
				},
				普陀山 = {
					黑熊精 = 0,
					蜘蛛精 = 0,
					激活 = 100
				},
				盘丝岭 = {
					狐狸精 = 0,
					蜘蛛精 = 0,
					花妖 = 0,
					激活 = 100
				},
				狮驼岭 = {
					激活 = 100,
					雷鸟人 = 0,
					蝴蝶仙子 = 0
				},
				西牛贺州 = {
					小龙女 = 0,
					狼 = 0,
					激活 = 100
				},
				花果山 = {
					小龙女 = 0,
					激活 = 100,
					老虎 = 0,
					黑熊 = 0
				},
				海底迷宫 = {
					激活 = 100,
					龟丞相 = 0,
					虾兵 = 0,
					蟹将 = 0
				},
				地狱迷宫 = {
					马面 = 0,
					骷髅怪 = 0,
					僵尸 = 0,
					牛头 = 0,
					激活 = 100,
					野鬼 = 0
				},
				北俱芦洲 = {
					激活 = 100,
					古代瑞兽 = 0,
					白熊 = 0,
					天将 = 0
				},
				龙窟 = {
					激活 = 100,
					古代瑞兽 = 0,
					天兵 = 0,
					雨师 = 0,
					蛟龙 = 0,
					风伯 = 0,
					星灵仙子 = 0,
					地狱战神 = 0,
					巡游天神 = 0,
					黑山老妖 = 0
				},
				凤巢 = {
					激活 = 100,
					风伯 = 0,
					天兵 = 0,
					天将 = 0,
					如意仙子 = 0,
					地狱战神 = 0,
					芙蓉仙子 = 0,
					凤凰 = 0,
					雷鸟人 = 0,
					黑山老妖 = 0
				},
				无名鬼城 = {
					激活 = 100,
					画魂 = 0,
					吸血鬼 = 0,
					幽萤娃娃 = 0,
					阴阳伞 = 0,
					幽灵 = 0,
					鬼将 = 0
				},
				小西天 = {
					激活 = 100,
					炎魔神 = 0,
					金铙僧 = 0,
					阴阳伞 = 0,
					噬天虎 = 0,
					夜罗刹 = 0
				},
				女娲神迹 = {
					激活 = 100,
					净瓶女娲 = 0,
					灵符女娲 = 0,
					阴阳伞 = 0,
					律法女娲 = 0
				},
				小雷音寺 = {
					激活 = 100,
					灵鹤 = 0,
					大力金刚 = 0,
					阴阳伞 = 0,
					雾中仙 = 0
				},
				蓬莱仙岛 = {
					踏云兽 = 0,
					龙龟 = 0,
					激活 = 100,
					阴阳伞 = 0,
					琴仙 = 0,
					红萼仙子 = 0
				},
				月宫 = {
					兔子怪 = 0,
					蜘蛛精 = 0,
					激活 = 100
				},
				蟠桃园 = {
					激活 = 100,
					长眉灵猴 = 0,
					巨力神猿 = 0,
					混沌兽 = 0
				},
				墨家禁地 = {
					机关鸟 = 0,
					巴蛇 = 0,
					机关兽 = 0,
					连弩车 = 0,
					阴阳伞 = 0,
					激活 = 100,
					机关人 = 0
				},
				解阳山 = {
					锦毛貂精 = 0,
					激活 = 100,
					千年蛇魅 = 0,
					犀牛将军人形 = 0,
					犀牛将军兽形 = 0
				},
				子母河底 = {
					激活 = 100,
					蚌精 = 0,
					碧水夜叉 = 0,
					鲛人 = 0
				},
				麒麟山 = {
					激活 = 100,
					鼠先锋 = 0,
					野猪精 = 0,
					镜妖 = 0,
					百足将军 = 0,
					泪妖 = 0
				},
				碗子山 = {
					蝎子精 = 0,
					激活 = 100,
					葫芦宝贝 = 0
				},
				波月洞 = {
					狂豹人形 = 0,
					猫灵兽形 = 0,
					激活 = 100,
					混沌兽 = 0,
					狂豹兽形 = 0,
					猫灵人形 = 0
				},
				柳林坡 = {
					蜃气妖 = 0,
					修罗傀儡鬼 = 0,
					藤蔓妖花 = 0,
					激活 = 100
				},
				比丘国 = {
					激活 = 100,
					金身罗汉 = 0,
					曼珠沙华 = 0,
					修罗傀儡妖 = 0
				},
				须弥东界 = {
					持国巡守 = 0,
					毗舍童子 = 0,
					真陀护法 = 0,
					灵灯侍者 = 0,
					般若天女 = 0,
					增长巡守 = 0,
					激活 = 100
				}
			}
		end

		发送数据(玩家数据[id].连接id, 3529.1, {
			图鉴系统[id]
		})
	elseif 序号 == 201 then
		local id = 内容.数字id + 0
		local 选项 = {}
		玩家数据[id].角色.图鉴提交 = {
			地图 = 内容.地图,
			名称 = 内容.名称
		}
		local 对话 = "提交宠物对话自行修改"

		for n = 1, #玩家数据[id].召唤兽.数据 do
			选项[#选项 + 1] = 玩家数据[id].召唤兽.数据[n].名称
		end

		发送数据(玩家数据[id].连接id, 1501, {
			名称 = 玩家数据[id].角色.数据.名称,
			模型 = 玩家数据[id].角色.数据.模型,
			对话 = 对话,
			选项 = 选项
		})
	elseif 序号 == 202 then
		local id = 内容.数字id + 0

		if 图鉴系统[id] == nil then
			图鉴系统[id] = {
				东海湾 = {
					激活 = 100,
					海星 = 0,
					巨蛙 = 0,
					大海龟 = 0,
					海毛虫 = 0,
					章鱼 = 0
				},
				江南野外 = {
					野猪 = 0,
					树怪 = 0,
					狸 = 0,
					激活 = 100
				},
				大雁塔 = {
					激活 = 100,
					骷髅怪 = 0,
					强盗 = 0,
					大蝙蝠 = 0,
					蛤蟆精 = 0,
					羊头怪 = 0,
					花妖 = 0,
					狐狸精 = 0,
					赌徒 = 0
				},
				大唐国境 = {
					护卫 = 0,
					山贼 = 0,
					强盗 = 0,
					激活 = 100,
					赌徒 = 0
				},
				大唐境外 = {
					激活 = 100,
					花妖 = 0,
					老虎 = 0,
					黑熊 = 0
				},
				魔王寨 = {
					激活 = 100,
					牛妖 = 0,
					蛤蟆精 = 0
				},
				普陀山 = {
					黑熊精 = 0,
					蜘蛛精 = 0,
					激活 = 100
				},
				盘丝岭 = {
					狐狸精 = 0,
					蜘蛛精 = 0,
					花妖 = 0,
					激活 = 100
				},
				狮驼岭 = {
					激活 = 100,
					雷鸟人 = 0,
					蝴蝶仙子 = 0
				},
				西牛贺州 = {
					小龙女 = 0,
					狼 = 0,
					激活 = 100
				},
				花果山 = {
					小龙女 = 0,
					激活 = 100,
					老虎 = 0,
					黑熊 = 0
				},
				海底迷宫 = {
					激活 = 100,
					龟丞相 = 0,
					虾兵 = 0,
					蟹将 = 0
				},
				地狱迷宫 = {
					马面 = 0,
					骷髅怪 = 0,
					僵尸 = 0,
					牛头 = 0,
					激活 = 100,
					野鬼 = 0
				},
				北俱芦洲 = {
					激活 = 100,
					古代瑞兽 = 0,
					白熊 = 0,
					天将 = 0
				},
				龙窟 = {
					激活 = 100,
					古代瑞兽 = 0,
					天兵 = 0,
					雨师 = 0,
					蛟龙 = 0,
					风伯 = 0,
					星灵仙子 = 0,
					地狱战神 = 0,
					巡游天神 = 0,
					黑山老妖 = 0
				},
				凤巢 = {
					激活 = 100,
					风伯 = 0,
					天兵 = 0,
					天将 = 0,
					如意仙子 = 0,
					地狱战神 = 0,
					芙蓉仙子 = 0,
					凤凰 = 0,
					雷鸟人 = 0,
					黑山老妖 = 0
				},
				无名鬼城 = {
					激活 = 100,
					画魂 = 0,
					吸血鬼 = 0,
					幽萤娃娃 = 0,
					阴阳伞 = 0,
					幽灵 = 0,
					鬼将 = 0
				},
				小西天 = {
					激活 = 100,
					炎魔神 = 0,
					金铙僧 = 0,
					阴阳伞 = 0,
					噬天虎 = 0,
					夜罗刹 = 0
				},
				女娲神迹 = {
					激活 = 100,
					净瓶女娲 = 0,
					灵符女娲 = 0,
					阴阳伞 = 0,
					律法女娲 = 0
				},
				小雷音寺 = {
					激活 = 100,
					灵鹤 = 0,
					大力金刚 = 0,
					阴阳伞 = 0,
					雾中仙 = 0
				},
				蓬莱仙岛 = {
					踏云兽 = 0,
					龙龟 = 0,
					激活 = 100,
					阴阳伞 = 0,
					琴仙 = 0,
					红萼仙子 = 0
				},
				月宫 = {
					兔子怪 = 0,
					蜘蛛精 = 0,
					激活 = 100
				},
				蟠桃园 = {
					激活 = 100,
					长眉灵猴 = 0,
					巨力神猿 = 0,
					混沌兽 = 0
				},
				墨家禁地 = {
					机关鸟 = 0,
					巴蛇 = 0,
					机关兽 = 0,
					连弩车 = 0,
					阴阳伞 = 0,
					激活 = 100,
					机关人 = 0
				},
				解阳山 = {
					锦毛貂精 = 0,
					激活 = 100,
					千年蛇魅 = 0,
					犀牛将军人形 = 0,
					犀牛将军兽形 = 0
				},
				子母河底 = {
					激活 = 100,
					蚌精 = 0,
					碧水夜叉 = 0,
					鲛人 = 0
				},
				麒麟山 = {
					激活 = 100,
					鼠先锋 = 0,
					野猪精 = 0,
					镜妖 = 0,
					百足将军 = 0,
					泪妖 = 0
				},
				碗子山 = {
					蝎子精 = 0,
					激活 = 100,
					葫芦宝贝 = 0
				},
				波月洞 = {
					狂豹人形 = 0,
					猫灵兽形 = 0,
					激活 = 100,
					混沌兽 = 0,
					狂豹兽形 = 0,
					猫灵人形 = 0
				},
				柳林坡 = {
					蜃气妖 = 0,
					修罗傀儡鬼 = 0,
					藤蔓妖花 = 0,
					激活 = 100
				},
				比丘国 = {
					激活 = 100,
					金身罗汉 = 0,
					曼珠沙华 = 0,
					修罗傀儡妖 = 0
				},
				须弥东界 = {
					持国巡守 = 0,
					毗舍童子 = 0,
					真陀护法 = 0,
					灵灯侍者 = 0,
					般若天女 = 0,
					增长巡守 = 0,
					激活 = 100
				}
			}
		end

		if 图鉴系统[id][内容.地图].激活 == 103 then
			常规提示(id, "#Y当前地图图策已全部激活，无法重复激活")

			return
		else
			if 内容.区分 == 1 then
				for n, v in pairs(图鉴系统[id][内容.地图]) do
					if 图鉴系统[id][内容.地图][n] < 1 or 图鉴系统[id][内容.地图][n] == 2 then
						常规提示(id, "#Y您的#R" .. n .. "#Y宝宝没有激活，不能进行总激活")

						return
					end
				end

				图鉴系统[id][内容.地图].激活 = 图鉴系统[id][内容.地图].激活 + 内容.区分
				图鉴系统[id] = table.loadstring(table.tostring(图鉴系统[id]))

				常规提示(id, "#Y恭喜你成功激活了" .. 内容.地图 .. "#R宝宝#Y图策")
			elseif 内容.区分 == 2 then
				for n, v in pairs(图鉴系统[id][内容.地图]) do
					if 图鉴系统[id][内容.地图][n] < 2 then
						常规提示(id, "#Y您的#R" .. n .. "#Y变异宝宝没有激活，不能进行总激活")

						return
					end
				end

				图鉴系统[id][内容.地图].激活 = 图鉴系统[id][内容.地图].激活 + 内容.区分

				常规提示(id, "#Y恭喜你成功激活了" .. 内容.地图 .. "#R变异#Y图策")

				图鉴系统[id] = table.loadstring(table.tostring(图鉴系统[id]))
			end

			发送数据(玩家数据[id].连接id, 3529.2, 图鉴系统[id])
		end
	elseif 序号 == 203 then
		local id = 内容.数字id

		if 图鉴系统[id][内容.地图].浣熊 ~= nil then
			图鉴系统[id][内容.地图].狸 = 图鉴系统[id][内容.地图].浣熊 + 0
			图鉴系统[id][内容.地图].浣熊 = nil
		end

		local 图鉴宠物 = 图鉴系统[id][内容.地图][内容.名称] + 0

		if 内容.激活类型 == 101 then
			图鉴系统[id] = table.loadstring(table.tostring(图鉴系统[id]))

			if 图鉴系统[id][内容.地图].激活 == 101 then
				常规提示(id, "#Y当前地图图策已激活无法重复激活")

				return
			elseif 图鉴系统[id][内容.地图][内容.名称] == 1 or 图鉴系统[id][内容.地图][内容.名称] == 3 then
				常规提示(id, "#Y当前地图图策" .. 内容.名称 .. "已激活无法重复收集")

				return
			elseif 玩家数据[id].召唤兽.数据[内容.宠物] == nil then
				常规提示(id, "#Y当前收集的宠物数据错误无法收集\n如果没读取成功,重新打开图鉴和读取下宠物面板再试")

				return
			elseif 玩家数据[id].召唤兽.数据[内容.宠物].模型 ~= 内容.名称 then
				常规提示(id, "#Y当前收集的宠物数据错误无法收集(变异宠物请将名字中的变异去除)\n如果没读取成功,重新打开图鉴和读取下宠物面板再试")

				return
			elseif 玩家数据[id].角色.数据.参战宝宝.认证码 ~= nil and 玩家数据[id].角色.数据.参战宝宝.认证码 == 玩家数据[id].召唤兽.数据[内容.宠物].认证码 then
				常规提示(id, "#Y参战宠物无法进行收集,请先取消参战")

				return
			else
				table.remove(玩家数据[id].召唤兽.数据, 内容.宠物)
				常规提示(id, "#Y恭喜你完成了对" .. 内容.地图 .. 内容.名称 .. "的收集")

				图鉴系统[id][内容.地图][内容.名称] = 图鉴宠物 + 1
				图鉴系统[id] = table.loadstring(table.tostring(图鉴系统[id]))

				发送数据(玩家数据[id].连接id, 3529.2, 图鉴系统[id])
			end
		elseif 内容.激活类型 == 102 then
			if 图鉴系统[id][内容.地图].激活 == 102 then
				常规提示(id, "#Y当前地图图策已激活无法重复激活")

				return
			elseif 图鉴系统[id][内容.地图][内容.名称] == 2 or 图鉴系统[id][内容.地图][内容.名称] == 3 then
				常规提示(id, "#Y当前地图图策" .. 内容.名称 .. "已激活无法重复收集")

				return
			elseif 玩家数据[id].召唤兽.数据[内容.宠物] == nil then
				常规提示(id, "#Y当前收集的宠物数据错误无法收集\n如果没读取成功,重新打开图鉴和读取下宠物面板再试")

				return
			elseif 玩家数据[id].召唤兽.数据[内容.宠物].模型 ~= 内容.名称 then
				常规提示(id, "#Y当前收集的宠物数据错误无法收集\n如果没读取成功,重新打开图鉴和读取下宠物面板再试")

				return
			elseif 玩家数据[id].角色.数据.参战宝宝.认证码 ~= nil and 玩家数据[id].角色.数据.参战宝宝.认证码 == 玩家数据[id].召唤兽.数据[内容.宠物].认证码 then
				常规提示(id, "#Y参战宠物无法进行收集,请先取消参战")

				return
			else
				table.remove(玩家数据[id].召唤兽.数据, 内容.宠物)
				常规提示(id, "#Y恭喜你完成了对" .. 内容.地图 .. 内容.名称 .. "的收集")

				图鉴系统[id][内容.地图][内容.名称] = 图鉴宠物 + 2
				图鉴系统[id] = table.loadstring(table.tostring(图鉴系统[id]))

				发送数据(玩家数据[id].连接id, 3529.2, 图鉴系统[id])
			end
		end
	elseif 序号 == 113 then
		local id = 内容.数字id
		local 编号 = 内容.编号

		if 玩家数据[id].助战.数据[编号].助战修炼经验 == nil or 玩家数据[id].助战.数据[编号].助战修炼经验.攻击经验 >= 1 or 玩家数据[id].助战.数据[编号].助战修炼经验.法术经验 >= 1 or 玩家数据[id].助战.数据[编号].助战修炼经验.防御经验 >= 1 or 玩家数据[id].助战.数据[编号].助战修炼经验.抗法经验 >= 1 then
			玩家数据[id].助战.数据[编号].助战修炼经验 = {
				防御经验 = 0,
				法术经验 = 0,
				抗法经验 = 0,
				攻击经验 = 0
			}
		end

		发送数据(玩家数据[id].连接id, 7001, {
			编号 = 编号,
			助战修炼 = 玩家数据[id].助战.数据[编号].当前修炼
		})
	elseif 序号 == 113.1 then
		local id = 内容.数字id
		local 编号 = 内容.编号

		if 玩家数据[id].助战.数据[编号].当前修炼.当前 ~= 内容.修炼类型 then
			玩家数据[id].助战.数据[编号].当前修炼.当前 = 内容.修炼类型

			常规提示(id, "#P" .. 玩家数据[id].助战.数据[编号].名称 .. "#Y的修炼类型已更改为#R" .. 内容.修炼类型)
			发送数据(玩家数据[id].连接id, 7002, {
				编号 = 编号,
				助战修炼 = 玩家数据[id].助战.数据[编号].当前修炼
			})
		end
	elseif 序号 == 113.2 then
		local id = 内容.数字id

		if (玩家数据[id].角色.数据.储备修炼 or 0) < 1 then
			常规提示(id, "你的#R储备修炼#Y不足。")

			return
		end

		local 编号 = 内容.编号
		local 修炼数据 = 玩家数据[id].助战.数据[编号].当前修炼[内容.修炼类型]

		if 修炼数据[3] <= 修炼数据[1] then
			常规提示(id, "该助战的#R" .. 内容.修炼类型 .. "#Y等级已经达到上限。")

			return
		else
			local aa = 计算修炼等级经验(修炼数据[1], 修炼数据[3]) - 修炼数据[2]
			aa = math.min(aa, 玩家数据[id].角色.数据.储备修炼)

			if aa <= 0 then
				aa = 1
			end

			玩家数据[id].助战:添加修炼经验(编号, aa, 内容.修炼类型)
			扣除储备修炼(id, aa)
		end
	elseif 序号 == 114 then
		local id = 内容.数字id
		local 编号 = 内容.编号

		if 玩家数据[id].助战.数据[编号].门派 == nil then
			常规提示(id, "未加入门派")

			return 0
		end

		if 玩家数据[id].助战.数据[编号].门派 ~= "无门派" and 玩家数据[id].助战.数据[编号].师门技能 == nil then
			玩家数据[id].助战.数据[编号].师门技能 = {}
			local 列表 = 取门派技能(玩家数据[id].助战.数据[编号].门派)

			for n = 1, #列表 do
				玩家数据[id].助战.数据[编号].师门技能[n] = jnzb()

				玩家数据[id].助战.数据[编号].师门技能[n]:置对象(列表[n])

				玩家数据[id].助战.数据[编号].师门技能[n].包含技能 = {}
				玩家数据[id].助战.数据[编号].师门技能[n].等级 = 0
				local w = 取包含技能(玩家数据[id].助战.数据[编号].师门技能[n].名称)

				for s = 1, #w do
					玩家数据[id].助战.数据[编号].师门技能[n].包含技能[s] = jnzb()

					玩家数据[id].助战.数据[编号].师门技能[n].包含技能[s]:置对象(w[s])

					玩家数据[id].助战.数据[编号].师门技能[n].包含技能[s].等级 = 0
					玩家数据[id].助战.数据[编号].师门技能[n].包含技能[s].学会 = false
				end
			end
		end

		发送数据(玩家数据[id].连接id, 7003, {
			等级 = 玩家数据[id].助战.数据[编号].等级,
			编号 = 编号,
			师门技能 = 玩家数据[id].助战.数据[编号].师门技能,
			门派 = 玩家数据[id].助战.数据[编号].门派
		})
	elseif 序号 == 116.1 then
		local id = 内容.数字id
		local 编号 = 内容.编号
		local 序号 = 内容.序列
		local 学习等级 = 内容.等级 or 1

		if 玩家数据[id].助战.数据[编号].技能属性 == nil then
			玩家数据[id].助战.数据[编号].技能属性 = {
				魔力 = 0,
				体质 = 0,
				力量 = 0,
				气血 = 0,
				敏捷 = 0,
				耐力 = 0,
				魔法 = 0,
				躲避 = 0,
				灵力 = 0,
				伤害 = 0,
				速度 = 0,
				命中 = 0,
				防御 = 0
			}
		end

		if 玩家数据[id].助战.数据[编号].师门技能[序号] == nil then
			常规提示(id, "你没有这样的技能")

			return
		elseif 玩家数据[id].助战.数据[编号].师门技能[序号].等级 >= 玩家数据[id].助战.数据[编号].等级 + 10 then
			常规提示(id, "门派技能不能超过角色等级+10")

			return
		elseif 师门技能上限等级 <= 玩家数据[id].助战.数据[编号].师门技能[序号].等级 then
			常规提示(id, "门派技能不能超过" .. 师门技能上限等级 .. "级")

			return
		else
			local 技能提升等级 = 0

			if 玩家数据[id].助战.数据[编号].师门技能[序号].等级 + 学习等级 <= math.min(玩家数据[id].助战.数据[编号].等级 + 10, 师门技能上限等级) then
				技能提升等级 = 学习等级
			else
				技能提升等级 = math.min(玩家数据[id].助战.数据[编号].等级 + 10, 师门技能上限等级) - 玩家数据[id].助战.数据[编号].师门技能[序号].等级
			end

			if 助战升级技能是否消耗 ~= 1 then
				local 临时消耗 = {
					经验 = 0,
					金钱 = 0
				}

				for i = 1, 技能提升等级 do
					if 玩家数据[id].助战.数据[编号].当前经验 < 临时消耗.经验 + 技能消耗.经验[玩家数据[id].助战.数据[编号].师门技能[序号].等级 + i] then
						技能提升等级 = i - 1

						break
					end

					临时消耗.经验 = 临时消耗.经验 + 技能消耗.经验[玩家数据[id].助战.数据[编号].师门技能[序号].等级 + i]
					临时消耗.金钱 = 临时消耗.金钱 + 技能消耗.金钱[玩家数据[id].助战.数据[编号].师门技能[序号].等级 + i]
				end

				if 技能提升等级 == 0 then
					常规提示(id, "学习技能失败、#P" .. 玩家数据[id].助战.数据[编号].名称 .. "#Y的经验不足#R" .. 数字转简(技能消耗.经验[玩家数据[id].助战.数据[编号].师门技能[序号].等级 + 1]) .. "#Y点")

					return
				end

				if 助战学习技能扣除金钱(id, 临时消耗.金钱, true) == false then
					常规提示(id, "你没有那么多的银两")

					return
				end

				玩家数据[id].助战:扣除经验(编号, 临时消耗.经验)
				刷新货币(连接id, id)
			end

			玩家数据[id].助战.数据[编号].师门技能[序号].等级 = 玩家数据[id].助战.数据[编号].师门技能[序号].等级 + 技能提升等级

			角色升级门派技能(玩家数据[id].助战.数据[编号], 玩家数据[id].助战.数据[编号].师门技能[序号])
			更新助战技能(id, 玩家数据[id].助战.数据[编号])
			发送数据(玩家数据[id].连接id, 7004, {
				等级 = 玩家数据[id].助战.数据[编号].等级,
				编号 = 编号,
				师门技能 = 玩家数据[id].助战.数据[编号].师门技能,
				门派 = 玩家数据[id].助战.数据[编号].门派
			})
			玩家数据[id].助战:刷新信息(编号)
			发送数据(玩家数据[id].连接id, 100, {
				编号 = 编号,
				数据 = 玩家数据[id].助战:取指定数据(编号)
			})
			发送数据(连接id, 31.1, {
				经验 = 玩家数据[id].角色.数据.当前经验
			})
		end
	elseif 序号 == 114.21 then
		local id = 内容.数字id

		if 玩家数据[id].角色.数据.助战消耗银两 ~= true then
			玩家数据[id].角色.数据.助战消耗银两 = true

			常规提示(id, "你#P开启#Y了助战学习技能可消耗银两")
		else
			玩家数据[id].角色.数据.助战消耗银两 = false

			常规提示(id, "你#P关闭#Y了助战学习技能可消耗银两")
		end

		发送数据(玩家数据[id].连接id, 104.5, 玩家数据[id].角色.数据.助战消耗银两)
	elseif 序号 == 114.2 then
		local id = 内容.数字id
		local 编号 = 内容.编号

		发送数据(玩家数据[id].连接id, 7005, {
			编号 = 编号,
			辅助技能 = 玩家数据[id].助战.数据[编号].辅助技能,
			强化技能 = 玩家数据[id].助战.数据[编号].强化技能
		})
	elseif 序号 == 114.3 then
		local id = 内容.数字id
		local 编号 = 内容.编号
		local 学习号 = 内容.学习号 + 0
		local 帮派编号 = 玩家数据[id].角色.数据.帮派数据.编号
		local 已学等级 = 0
		local 总消耗 = {
			经验 = 0,
			银子 = 0,
			储备 = 0
		}

		for i = 1, 玩家数据[id].角色.数据.助战辅助技能学习次数 do
			if 助战辅助技能数量 < 学习号 then
				local 学习号1 = 角色强化技能列表1["强化" .. 助战辅助技能[学习号]]

				if 学习号1 == nil then
					常规提示(id, "错误的技能、学习失败！")

					break
				elseif 玩家数据[id].助战.数据[编号].强化技能[学习号1].等级 >= 玩家数据[id].助战.数据[编号].等级 + 10 then
					常规提示(id, "该技能最多不超过助战等级的10级")

					break
				elseif 辅助强化技能最高等级 <= 玩家数据[id].助战.数据[编号].强化技能[学习号1].等级 then
					常规提示(id, "该技能等级已经达到上限")

					break
				end

				local 临时消耗 = {}

				if 玩家数据[id].助战.数据[编号].强化技能[学习号1].等级 < 40 then
					临时消耗 = 取生活技能消耗(玩家数据[id].助战.数据[编号].强化技能[学习号1].等级 + 1)
				else
					临时消耗 = 取生活技能消耗(玩家数据[id].助战.数据[编号].强化技能[学习号1].等级 + 1, "消耗帮贡")
				end

				临时消耗.经验 = 临时消耗.经验 * 强化技能消耗倍率
				临时消耗.金钱 = 临时消耗.金钱 * 强化技能消耗倍率
				local 帮贡需求 = 临时消耗.帮贡 or 0

				if 玩家数据[id].助战.数据[编号].当前经验 < 临时消耗.经验 then
					常规提示(id, "学习技能失败、#P" .. 玩家数据[id].助战.数据[编号].名称 .. "#Y的经验不足#R" .. 数字转简(临时消耗.经验) .. "#Y点")

					break
				elseif 助战学习技能扣除金钱(id, 临时消耗.金钱) == false then
					常规提示(id, "学习技能失败、需要消耗#R" .. 数字转简(临时消耗.金钱) .. "#Y储备或银两")

					break
				elseif 帮贡需求 > 0 and 扣除帮贡(id, 帮贡需求) == false then
					常规提示(id, "你的帮贡低于#R" .. 帮贡需求 .. "#Y点、学习失败！")

					break
				end

				玩家数据[id].助战:扣除经验(编号, 临时消耗.经验)
				助战学习技能扣除金钱(id, 临时消耗.金钱, true)

				玩家数据[id].助战.数据[编号].强化技能[学习号1].等级 = 玩家数据[id].助战.数据[编号].强化技能[学习号1].等级 + 1
				玩家数据[id].助战.数据[编号].辅助技能[学习号].等级 = 玩家数据[id].助战.数据[编号].强化技能[学习号1].等级 + 0
				已学等级 = 已学等级 + 1
			else
				local 神速倍率 = 1

				if 玩家数据[id].助战.数据[编号].辅助技能[学习号].名称 == "神速" or 玩家数据[id].助战.数据[编号].辅助技能[学习号].名称 == "强壮" then
					if 强壮神速最高等级 <= 玩家数据[id].助战.数据[编号].辅助技能[学习号].等级 then
						常规提示(id, "#P" .. 玩家数据[id].助战.数据[编号].名称 .. "#Y的这个技能已经升到满级了")

						break
					elseif 玩家数据[id].助战.数据[编号].等级 < 玩家数据[id].助战.数据[编号].辅助技能[学习号].等级 * 3 then
						常规提示(id, "学习失败、该技能等级不能超过【助战等级÷3】")

						break
					end

					神速倍率 = 3
				elseif 玩家数据[id].助战.数据[编号].辅助技能[学习号].等级 >= 玩家数据[id].助战.数据[编号].等级 + 10 then
					常规提示(id, "该技能最多不超过助战等级的10级")

					break
				elseif 辅助强化技能最高等级 <= 玩家数据[id].助战.数据[编号].辅助技能[学习号].等级 then
					常规提示(id, "该技能等级已经达到上限")

					break
				end

				local 临时消耗 = {}

				if 玩家数据[id].助战.数据[编号].辅助技能[学习号].等级 < 40 then
					临时消耗 = 取生活技能消耗((玩家数据[id].助战.数据[编号].辅助技能[学习号].等级 + 1) * 神速倍率)
				else
					临时消耗 = 取生活技能消耗((玩家数据[id].助战.数据[编号].辅助技能[学习号].等级 + 1) * 神速倍率, "消耗帮贡")
				end

				local 帮贡需求 = 临时消耗.帮贡 or 0

				if 玩家数据[id].助战.数据[编号].当前经验 < 临时消耗.经验 then
					常规提示(id, "学习技能失败、#P" .. 玩家数据[id].助战.数据[编号].名称 .. "#Y的经验不足#R" .. 数字转简(临时消耗.经验) .. "#Y点")

					break
				elseif 助战学习技能扣除金钱(id, 临时消耗.金钱) == false then
					常规提示(id, "学习技能失败、需要消耗#R" .. 数字转简(临时消耗.金钱) .. "#Y储备或银两")

					break
				elseif 帮贡需求 > 0 and 扣除帮贡(id, 帮贡需求) == false then
					常规提示(id, "你的帮贡低于#R" .. 帮贡需求 .. "#Y点、学习失败！")

					break
				end

				玩家数据[id].助战:扣除经验(编号, 临时消耗.经验)
				助战学习技能扣除金钱(id, 临时消耗.金钱, true)

				玩家数据[id].助战.数据[编号].辅助技能[学习号].等级 = 玩家数据[id].助战.数据[编号].辅助技能[学习号].等级 + 1
				已学等级 = 已学等级 + 1
			end
		end

		if 已学等级 > 0 then
			玩家数据[id].助战:刷新信息(编号)
			发送数据(玩家数据[id].连接id, 7006, {
				是否 = 1,
				编号 = 编号,
				辅助技能 = 玩家数据[id].助战.数据[编号].辅助技能,
				强化技能 = 玩家数据[id].助战.数据[编号].强化技能
			})
			发送数据(玩家数据[id].连接id, 100, {
				编号 = 编号,
				数据 = 玩家数据[id].助战:取指定数据(编号)
			})
		end
	elseif 序号 == 114.4 then
		local id = 内容.数字id
		local 编号 = 内容.编号

		if 门派名称1[玩家数据[id].助战.数据[编号].门派] == nil then
			常规提示(id, "请先加入门派！")

			return
		end

		发送数据(玩家数据[id].连接id, 7007, {
			编号 = 编号,
			流派 = 玩家数据[id].助战.数据[编号].经脉流派,
			模型 = 玩家数据[id].助战.数据[编号].模型,
			门派 = 玩家数据[id].助战.数据[编号].门派,
			奇经八脉 = 玩家数据[id].助战.数据[编号].奇经八脉,
			装备属性 = 玩家数据[id].助战.数据[编号].装备属性
		})
	elseif 序号 == 114.5 then
		local id = 内容.数字id
		local 编号 = 内容.编号
		local 位置 = 内容.序列

		增加奇经八脉(id, 位置, 玩家数据[id].助战.数据[编号], 编号)
	elseif 序号 == 114.6 then
		local id = 内容.数字id
		local 编号 = 内容.编号

		self:清空奇经八脉(id, 编号)
	elseif 序号 == 114.7 then
		local id = 内容.数字id
		local 编号 = 内容.编号

		self:兑换乾元丹(id, 编号)
	elseif 序号 == 114.71 then
		local id = 内容.数字id

		玩家数据[id].角色:兑换乾元丹(id)
	elseif 序号 == 114.72 then
		local id = 内容.数字id
		local 助战编号 = 内容.编号

		切换经脉流派(id, 玩家数据[id].助战.数据[助战编号], 内容.流派, 助战编号)
	elseif 序号 == 114.73 then
		local id = 内容.数字id

		切换经脉流派(id, 玩家数据[id].角色.数据, 内容.流派)
	elseif 序号 == 114.8 then
		local id = 内容.数字id
		local 编号 = 内容.编号
		锦衣数据 = {}

		if 玩家数据[id].助战.数据[编号].锦衣[1] ~= nil then
			锦衣数据[1] = table.loadstring(table.tostring(玩家数据[id].道具.数据[玩家数据[id].助战.数据[编号].锦衣[1]]))
		end

		if 玩家数据[id].助战.数据[编号].锦衣[2] ~= nil then
			锦衣数据[2] = table.loadstring(table.tostring(玩家数据[id].道具.数据[玩家数据[id].助战.数据[编号].锦衣[2]]))
		end

		if 玩家数据[id].助战.数据[编号].锦衣[3] ~= nil then
			锦衣数据[3] = table.loadstring(table.tostring(玩家数据[id].道具.数据[玩家数据[id].助战.数据[编号].锦衣[3]]))
		end

		if 玩家数据[id].助战.数据[编号].锦衣[4] ~= nil then
			锦衣数据[4] = table.loadstring(table.tostring(玩家数据[id].道具.数据[玩家数据[id].助战.数据[编号].锦衣[4]]))
		end

		发送数据(玩家数据[id].连接id, 7009, {
			编号 = 编号,
			锦衣 = 锦衣数据
		})
	elseif 序号 == 114.9 then
		local id = 内容.数字id
		local 编号 = 内容.编号
		self.发送数据 = {
			法宝 = {}
		}

		for n = 1, 3 do
			if 玩家数据[id].助战.数据[编号].法宝佩戴[n] ~= nil then
				self.发送数据.法宝[n] = table.loadstring(table.tostring(玩家数据[id].道具.数据[玩家数据[id].助战.数据[编号].法宝佩戴[n]]))
			end
		end

		发送数据(玩家数据[id].连接id, 7011, {
			法宝 = self.发送数据,
			编号 = 编号
		})
	elseif 序号 == 114.91 then
		local id = 内容.数字id
		local 助战编号 = 内容.编号
		local 物品编号 = 内容.物品编号

		玩家数据[id].助战:佩戴法宝(玩家数据[id].连接id, id, "道具", 物品编号, 助战编号)
	elseif 序号 == 114.92 then
		local id = 内容.数字id
		local 助战编号 = 内容.编号
		local 物品编号 = 内容.物品编号

		玩家数据[id].助战:卸下法宝(玩家数据[id].连接id, id, 物品编号, 助战编号)
	elseif 序号 == 114.93 then
		local id = 内容.数字id
		local 编号 = 内容.编号
		玩家数据[id].助战.数据[编号].坐骑 = {
			坐骑拥有 = true
		}

		玩家数据[id].助战:刷新信息(编号)
		发送数据(玩家数据[id].连接id, 100, {
			编号 = 编号,
			数据 = 玩家数据[id].助战:取指定数据(编号)
		})
	elseif 序号 == 117.1 then
		local id = 内容.数字id

		if 玩家数据[id].角色.数据.转盘次数 == nil then
			玩家数据[id].角色.数据.转盘次数 = 0
			玩家数据[id].角色.数据.转盘开奖 = 0
		end
	elseif 序号 == 117.2 then
		local id = 内容.数字id

		if 玩家数据[id].角色.数据.转盘开奖 < 1 then
			常规提示(id, "#Y/你当日活跃度不足！")

			return
		else
			玩家数据[id].角色.数据.转盘开奖 = 玩家数据[id].角色.数据.转盘开奖 - 1
			local 奖励参数 = 取随机数(1, 100)

			if 奖励参数 <= 10 then
				local 名称 = "怪物卡片"

				玩家数据[id].道具:给予道具(id, 名称, 取随机数(5, 8))
				常规提示(id, "#Y/获得了" .. 名称)
			elseif 奖励参数 <= 20 then
				local 名称 = 玩家数据[id].道具:取五宝()

				玩家数据[id].道具:给予道具(id, 名称)
				常规提示(id, "#Y/你获得了" .. 名称)
			elseif 奖励参数 <= 30 then
				local 名称 = 取宝石()

				玩家数据[id].道具:给予道具(id, 名称, 取随机数(1, 2))
				常规提示(id, "#Y/你获得了" .. 名称)
			elseif 奖励参数 <= 35 then
				local 名称 = "摇钱树苗"

				玩家数据[id].道具:给予道具(id, 名称)
				常规提示(id, "#Y/你获得了" .. 名称)
			elseif 奖励参数 <= 50 then
				local 名称 = "金柳露"

				玩家数据[id].道具:给予道具(id, 名称, 1)
				常规提示(id, "#Y/你获得了" .. 名称)
			elseif 奖励参数 <= 60 then
				local 名称 = "彩果"

				玩家数据[id].道具:给予道具(id, 名称, 1)
				常规提示(id, "#Y/你获得了" .. 名称)
			elseif 奖励参数 <= 70 then
				local 名称 = 取宝石()

				玩家数据[id].道具:给予道具(id, 名称, 取随机数(2, 2))
				常规提示(id, "#Y/你获得了" .. 名称)
			else
				玩家数据[id].角色:添加经验(50000, "转盘开奖", 1)
			end
		end
	elseif 序号 == 118 then
		local id = 内容.数字id

		if not 玩家数据[id].角色.数据.接受给予 then
			玩家数据[id].角色.数据.接受给予 = true
		else
			玩家数据[id].角色.数据.接受给予 = false
		end

		if 玩家数据[id].角色.数据.接受给予 then
			常规提示(id, "#Y您已开启给予接受开关！")
		else
			常规提示(id, "#Y您已关闭给予接受开关！")
		end

		发送数据(玩家数据[id].连接id, 150, {
			接受给予 = 玩家数据[id].角色.数据.接受给予
		})
	elseif 序号 == 118.1 then
		local id = 内容.数字id

		if 是否月卡用户(id) then
			if not 玩家数据[id].角色.数据.自动捉宠 then
				玩家数据[id].角色.数据.自动捉宠 = true
			else
				玩家数据[id].角色.数据.自动捉宠 = false
			end

			if 玩家数据[id].角色.数据.自动捉宠 then
				常规提示(id, "#Y您已开启#P遇变异神兽自动捕捉#Y(自动战斗情况下)！")
			else
				常规提示(id, "#Y您已关闭#P遇变异神兽自动捕捉#Y(自动战斗情况下)！")
			end
		else
			玩家数据[id].角色.数据.自动捉宠 = false

			常规提示(id, "#Y您不是#P月卡用户#Y、无法使用此功能！")
		end

		发送数据(玩家数据[id].连接id, 150.1, {
			自动捉宠 = 玩家数据[id].角色.数据.自动捉宠
		})
	elseif 序号 == 901 then
		local id = 内容.数字id

		self:刷新交易数据(id, 内容)
	elseif 序号 == 902 then
		local id = 内容.数字id

		self:购买交易中心商品(id, 内容)
	elseif 序号 == 903 then
		local id = 内容.数字id

		self:出售交易中心商品(id, 内容)
	end
end

function 系统处理类:刷新助战灵饰(id, 编号)
	锦衣数据 = {}

	if 玩家数据[id].助战.数据[编号].锦衣[1] ~= nil then
		锦衣数据[1] = table.loadstring(table.tostring(玩家数据[id].道具.数据[玩家数据[id].助战.数据[编号].锦衣[1]]))
	end

	if 玩家数据[id].助战.数据[编号].锦衣[2] ~= nil then
		锦衣数据[2] = table.loadstring(table.tostring(玩家数据[id].道具.数据[玩家数据[id].助战.数据[编号].锦衣[2]]))
	end

	if 玩家数据[id].助战.数据[编号].锦衣[3] ~= nil then
		锦衣数据[3] = table.loadstring(table.tostring(玩家数据[id].道具.数据[玩家数据[id].助战.数据[编号].锦衣[3]]))
	end

	if 玩家数据[id].助战.数据[编号].锦衣[4] ~= nil then
		锦衣数据[4] = table.loadstring(table.tostring(玩家数据[id].道具.数据[玩家数据[id].助战.数据[编号].锦衣[4]]))
	end

	发送数据(玩家数据[id].连接id, 107.1, {
		编号 = 编号,
		锦衣 = 锦衣数据
	})
end

function 系统处理类:清空奇经八脉(id, 编号)
	local 清空奇经八脉费用 = 1000000

	if 取银子(id) < 清空奇经八脉费用 then
		常规提示(id, "#Y/你当前的银两不够清空奇经八脉哦，清空奇经八脉需要" .. 清空奇经八脉费用 .. "两银子！")

		return
	end

	if 玩家数据[id].助战.数据[编号].装备属性.乾元丹 ~= nil and 玩家数据[id].助战.数据[编号].装备属性.乾元丹 == 0 then
		常规提示(id, "#Y/你当前没有可清空的奇经八脉！")

		return
	end

	玩家数据[id].角色:扣除银子(清空奇经八脉费用, 0, 0, "清空奇经八脉费用", 1)

	玩家数据[id].助战.数据[编号].奇经八脉 = {
		技能树 = {
			1,
			2,
			3
		}
	}
	玩家数据[id].助战.数据[编号].开启奇经八脉 = nil
	玩家数据[id].助战.数据[编号].技能树 = nil
	玩家数据[id].助战.数据[编号].装备属性.剩余乾元丹 = 玩家数据[id].助战.数据[编号].装备属性.剩余乾元丹 + 玩家数据[id].助战.数据[编号].装备属性.乾元丹
	玩家数据[id].助战.数据[编号].装备属性.乾元丹 = 0

	常规提示(id, "#Y/恭喜你，经脉重置成功！")
	发送数据(玩家数据[id].连接id, 7008.1)
end

function 系统处理类:兑换乾元丹(id, 编号)
	local 附加乾元丹 = 玩家数据[id].助战.数据[编号].装备属性.附加乾元丹
	local 乾元丹消耗 = 取乾元丹消耗(附加乾元丹 + 1)

	if 取银子(id) < 乾元丹消耗.金钱 then
		常规提示(id, "#Y/你当前的银两不够兑换乾元丹！兑换所需#P" .. 数字转简(乾元丹消耗.金钱) .. "两")

		return
	end

	if 玩家数据[id].助战.数据[编号].当前经验 < 乾元丹消耗.经验 then
		常规提示(id, "#P" .. 玩家数据[id].助战.数据[编号].名称 .. "#Y当前的经验不够兑换乾元丹！兑换所需#P" .. 数字转简(乾元丹消耗.经验) .. "点经验")

		return
	end

	if 玩家数据[id].助战.数据[编号].装备属性.可换乾元丹 <= 玩家数据[id].助战.数据[编号].装备属性.附加乾元丹 then
		常规提示(id, "#P" .. 玩家数据[id].助战.数据[编号].名称 .. "#Y当前不满足兑换乾元丹的条件哦！")

		return
	end

	玩家数据[id].角色:扣除银子(乾元丹消耗.金钱, 0, 0, "乾元丹消耗", 1)

	玩家数据[id].助战.数据[编号].当前经验 = 玩家数据[id].助战.数据[编号].当前经验 - 乾元丹消耗.经验

	常规提示(id, "#P" .. 玩家数据[id].助战.数据[编号].名称 .. "#Y失去了#R" .. 数字转简(乾元丹消耗.经验) .. "#Y点经验！")

	玩家数据[id].助战.数据[编号].装备属性.附加乾元丹 = 玩家数据[id].助战.数据[编号].装备属性.附加乾元丹 + 1
	玩家数据[id].助战.数据[编号].装备属性.剩余乾元丹 = 玩家数据[id].助战.数据[编号].装备属性.剩余乾元丹 + 1

	添加最后对话(id, "兑换乾元丹成功！")
	发送数据(玩家数据[id].连接id, 7008, {
		编号 = 编号,
		流派 = 玩家数据[id].助战.数据[编号].经脉流派,
		门派 = 玩家数据[id].助战.数据[编号].门派,
		奇经八脉 = 玩家数据[id].助战.数据[编号].奇经八脉,
		装备属性 = 玩家数据[id].助战.数据[编号].装备属性
	})
end

师门技能升级属性 = {
	灵力 = 1.5,
	伤害 = 2.5,
	速度 = 0.3,
	气血 = 3,
	躲避 = 2.5,
	命中 = 2.5,
	魔法 = 3,
	防御 = 1.5
}

角色升级技能 = function(jn, 角色数据)
	if jn.等级 == nil then
		jn.等级 = 0
	end

	local 符石等级 = math.max(math.min(角色数据.装备属性[jn.名称 .. "等级"] or 0, 符石技能等级[4] * 2), 0)
	local 计算等级 = jn.等级 + 符石等级
	local floor = math.floor

	if jn.名称 == "小乘佛法" then
		角色数据.技能属性.灵力 = floor(计算等级 * 师门技能升级属性.灵力)
	elseif jn.名称 == "金刚伏魔" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "大慈大悲" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "渡世步" then
		角色数据.技能属性.躲避 = floor(计算等级 * 师门技能升级属性.躲避)
	elseif jn.名称 == "无双一击" then
		角色数据.技能属性.命中 = floor(计算等级 * 师门技能升级属性.命中)
	elseif jn.名称 == "神兵鉴赏" then
		角色数据.技能属性.躲避 = floor(计算等级 * 师门技能升级属性.躲避)
	elseif jn.名称 == "十方无敌" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "紫薇之术" then
		角色数据.技能属性.灵力 = floor(计算等级 * 师门技能升级属性.灵力)
	elseif jn.名称 == "文韬武略" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "九龙诀" then
		角色数据.技能属性.灵力 = floor(计算等级 * 师门技能升级属性.灵力)
	elseif jn.名称 == "破浪诀" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "逆鳞术" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "游龙术" then
		角色数据.技能属性.躲避 = floor(计算等级 * 师门技能升级属性.躲避)
	elseif jn.名称 == "磐龙灭法" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "归元心法" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "神道无念" then
		角色数据.技能属性.灵力 = floor(计算等级 * 师门技能升级属性.灵力)
	elseif jn.名称 == "斜月步" then
		角色数据.技能属性.躲避 = floor(计算等级 * 师门技能升级属性.躲避)
	elseif jn.名称 == "六道轮回" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "九幽阴魂" then
		角色数据.技能属性.灵力 = floor(计算等级 * 师门技能升级属性.灵力)
	elseif jn.名称 == "尸腐恶" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "无常步" then
		角色数据.技能属性.速度 = floor(计算等级 * 师门技能升级属性.速度)
	elseif jn.名称 == "天罡气" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "宁气诀" then
		角色数据.技能属性.灵力 = floor(计算等级 * 师门技能升级属性.灵力)
	elseif jn.名称 == "清明自在" then
		角色数据.技能属性.气血 = floor(计算等级 * 师门技能升级属性.气血)
	elseif jn.名称 == "乾坤塔" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "云霄步" then
		角色数据.技能属性.躲避 = floor(计算等级 * 师门技能升级属性.躲避)
	elseif jn.名称 == "裂石步" then
		角色数据.技能属性.躲避 = floor(计算等级 * 师门技能升级属性.躲避)
	elseif jn.名称 == "震天诀" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "火牛阵" then
		角色数据.技能属性.灵力 = floor(计算等级 * 师门技能升级属性.灵力)
	elseif jn.名称 == "回身击" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "裂石步" then
		角色数据.技能属性.速度 = floor(计算等级 * 师门技能升级属性.速度)
	elseif jn.名称 == "灵性" then
		角色数据.技能属性.灵力 = floor(计算等级 * 师门技能升级属性.灵力)
	elseif jn.名称 == "护法金刚" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "五行扭转" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "莲花宝座" then
		角色数据.技能属性.躲避 = floor(计算等级 * 师门技能升级属性.躲避)
	elseif jn.名称 == "周易学" then
		角色数据.技能属性.魔法 = floor(计算等级 * 师门技能升级属性.魔法)
	elseif jn.名称 == "潇湘仙雨" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "混元道果" then
		角色数据.技能属性.灵力 = floor(计算等级 * 师门技能升级属性.灵力)
	elseif jn.名称 == "明性修身" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "七星遁" then
		角色数据.技能属性.躲避 = floor(计算等级 * 师门技能升级属性.躲避)
	elseif jn.名称 == "生死搏" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "训兽诀" then
		角色数据.技能属性.灵力 = floor(计算等级 * 师门技能升级属性.灵力)
	elseif jn.名称 == "大鹏展翅" then
		角色数据.技能属性.躲避 = floor(计算等级 * 师门技能升级属性.躲避)
	elseif jn.名称 == "魔兽反噬" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "秋波暗送" then
		角色数据.技能属性.命中 = floor(计算等级 * 师门技能升级属性.命中)
	elseif jn.名称 == "蛛丝阵法" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "盘丝大法" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "盘丝步" then
		角色数据.技能属性.躲避 = floor(计算等级 * 师门技能升级属性.躲避)
	elseif jn.名称 == "气吞山河" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "啸傲" then
		角色数据.技能属性.灵力 = floor(计算等级 * 师门技能升级属性.灵力)
	elseif jn.名称 == "诛魔" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "法天象地" then
		角色数据.技能属性.命中 = floor(计算等级 * 师门技能升级属性.命中)
	elseif jn.名称 == "万灵诸念" then
		角色数据.技能属性.灵力 = floor(计算等级 * 师门技能升级属性.灵力)
	elseif jn.名称 == "巫咒" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "万物轮转" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "天人庇护" then
		角色数据.技能属性.躲避 = floor(计算等级 * 师门技能升级属性.躲避)
	elseif jn.名称 == "驭灵咒" then
		角色数据.技能属性.魔法 = floor(计算等级 * 师门技能升级属性.魔法)
	elseif jn.名称 == "鬼蛊灵蕴" then
		角色数据.技能属性.灵力 = floor(计算等级 * 师门技能升级属性.灵力)
	elseif jn.名称 == "燃灯灵宝" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "混元神功" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "秘影迷踪" then
		角色数据.技能属性.速度 = floor(计算等级 * 师门技能升级属性.速度)
	elseif jn.名称 == "毒经" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "香飘兰麝" then
		角色数据.技能属性.灵力 = floor(计算等级 * 师门技能升级属性.灵力)
	elseif jn.名称 == "玉质冰肌" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "清歌妙舞" then
		角色数据.技能属性.速度 = floor(计算等级 * 师门技能升级属性.速度)
	elseif jn.名称 == "天罚之焰" then
		角色数据.技能属性.灵力 = floor(计算等级 * 师门技能升级属性.灵力)
	elseif jn.名称 == "煌火无明" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "弹指成烬" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "藻光灵狱" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "离魂" then
		角色数据.技能属性.速度 = floor(计算等级 * 师门技能升级属性.速度)
	elseif jn.名称 == "千机奇巧" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "匠心不移" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "运思如电" then
		角色数据.技能属性.躲避 = floor(计算等级 * 师门技能升级属性.躲避)
	elseif jn.名称 == "探奥索隐" then
		角色数据.技能属性.灵力 = floor(计算等级 * 师门技能升级属性.灵力)
	elseif jn.名称 == "如意金箍" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "金刚之躯" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "灵猴九窍" then
		角色数据.技能属性.命中 = floor(计算等级 * 师门技能升级属性.命中)
	elseif jn.名称 == "七十二变" then
		角色数据.技能属性.灵力 = floor(计算等级 * 师门技能升级属性.灵力)
	elseif jn.名称 == "魂枫战舞" then
		角色数据.技能属性.伤害 = floor(计算等级 * 师门技能升级属性.伤害)
	elseif jn.名称 == "兵铸乾坤" then
		角色数据.技能属性.灵力 = floor(计算等级 * 师门技能升级属性.灵力)
	elseif jn.名称 == "燃铁飞花" then
		角色数据.技能属性.命中 = floor(计算等级 * 师门技能升级属性.命中)
	elseif jn.名称 == "战火雄魂" then
		角色数据.技能属性.防御 = floor(计算等级 * 师门技能升级属性.防御)
	elseif jn.名称 == "风行九黎" then
		角色数据.技能属性.躲避 = floor(计算等级 * 师门技能升级属性.躲避)
	end
end

function 系统处理类:剑会天下单人匹配处理()
	if 判断是否为空表(剑会天下单人匹配) then
		return
	end

	table.sort(剑会天下单人匹配, 积分排序)

	for n, v in pairs(剑会天下单人匹配) do
		if 玩家数据[v.id] ~= nil and v.匹配 and 玩家数据[v.id].战斗 == 0 and 玩家数据[v.id].观战 == nil then
			local 红方玩家id = v.id
			v.匹配 = false
			local 蓝方玩家id = 0

			if n % 2 == 1 then
				if n ~= #剑会天下单人匹配 then
					蓝方玩家id = 剑会天下单人匹配[n + 1].id or 0
					剑会天下单人匹配[n + 1].匹配 = false
				else
					local 剑会假人属性 = {}
					local 武器伤害 = 0

					if 玩家数据[红方玩家id].角色.数据.装备[3] ~= nil then
						local 临时武器 = table.loadstring(table.tostring(玩家数据[红方玩家id].道具.数据[玩家数据[红方玩家id].角色.数据.装备[3]]))
						武器伤害 = qz(临时武器.伤害 + 临时武器.命中 * 0.3)
					end

					剑会假人属性[#剑会假人属性 + 1] = {
						角色分类 = "角色",
						位置 = 1,
						名称 = 取随机中文姓名(取随机数(2, 5)),
						模型 = 玩家数据[红方玩家id].角色.数据.模型,
						等级 = 玩家数据[红方玩家id].角色.数据.等级,
						气血 = 玩家数据[红方玩家id].角色.数据.最大气血,
						魔法 = 玩家数据[红方玩家id].角色.数据.最大魔法,
						伤害 = 玩家数据[红方玩家id].角色.数据.伤害,
						灵力 = 玩家数据[红方玩家id].角色.数据.灵力 + 玩家数据[红方玩家id].角色.数据.法伤,
						速度 = 玩家数据[红方玩家id].角色.数据.速度,
						防御 = 玩家数据[红方玩家id].角色.数据.防御,
						法防 = 玩家数据[红方玩家id].角色.数据.灵力 + 玩家数据[红方玩家id].角色.数据.法防,
						攻击修炼 = 玩家数据[红方玩家id].角色.数据.修炼.攻击修炼[1],
						法术修炼 = 玩家数据[红方玩家id].角色.数据.修炼.法术修炼[1],
						防御修炼 = 玩家数据[红方玩家id].角色.数据.修炼.防御修炼[1],
						抗法修炼 = 玩家数据[红方玩家id].角色.数据.修炼.抗法修炼[1],
						门派 = 玩家数据[红方玩家id].角色.数据.门派,
						五维属性 = {
							体质 = 玩家数据[红方玩家id].角色.数据.体质,
							魔力 = 玩家数据[红方玩家id].角色.数据.魔力,
							力量 = 玩家数据[红方玩家id].角色.数据.力量,
							耐力 = 玩家数据[红方玩家id].角色.数据.耐力,
							敏捷 = 玩家数据[红方玩家id].角色.数据.敏捷
						},
						武器伤害 = 武器伤害
					}

					if not 判断是否为空表(玩家数据[红方玩家id].角色.数据.参战宝宝) then
						剑会假人属性[#剑会假人属性 + 1] = {
							位置 = 6,
							名称 = 玩家数据[红方玩家id].角色.数据.参战宝宝.模型,
							模型 = 玩家数据[红方玩家id].角色.数据.参战宝宝.模型,
							等级 = 玩家数据[红方玩家id].角色.数据.参战宝宝.等级,
							气血 = 玩家数据[红方玩家id].角色.数据.参战宝宝.最大气血,
							魔法 = 玩家数据[红方玩家id].角色.数据.参战宝宝.最大魔法,
							伤害 = 玩家数据[红方玩家id].角色.数据.参战宝宝.伤害,
							灵力 = 玩家数据[红方玩家id].角色.数据.参战宝宝.灵力,
							速度 = 玩家数据[红方玩家id].角色.数据.参战宝宝.速度,
							防御 = 玩家数据[红方玩家id].角色.数据.参战宝宝.防御,
							法防 = 玩家数据[红方玩家id].角色.数据.参战宝宝.灵力 * 0.7,
							攻击修炼 = 玩家数据[红方玩家id].角色.数据.bb修炼.攻击控制力[1],
							法术修炼 = 玩家数据[红方玩家id].角色.数据.bb修炼.法术控制力[1],
							防御修炼 = 玩家数据[红方玩家id].角色.数据.bb修炼.防御控制力[1],
							抗法修炼 = 玩家数据[红方玩家id].角色.数据.bb修炼.抗法控制力[1],
							技能 = 玩家数据[红方玩家id].角色.数据.参战宝宝.技能,
							参战等级 = 玩家数据[红方玩家id].角色.数据.参战宝宝.参战等级,
							五维属性 = {
								体质 = 玩家数据[红方玩家id].角色.数据.参战宝宝.体质,
								魔力 = 玩家数据[红方玩家id].角色.数据.参战宝宝.魔力,
								力量 = 玩家数据[红方玩家id].角色.数据.参战宝宝.力量,
								耐力 = 玩家数据[红方玩家id].角色.数据.参战宝宝.耐力,
								敏捷 = 玩家数据[红方玩家id].角色.数据.参战宝宝.敏捷
							},
							内丹数据 = 玩家数据[红方玩家id].角色.数据.参战宝宝.内丹数据
						}
					end

					发送数据(玩家数据[红方玩家id].连接id, 128)
					常规提示(红方玩家id, "#Y/进入剑会天下PK战斗")
					战斗准备类:创建战斗(红方玩家id, 110001, 0, nil, 剑会假人属性)
				end
			end

			if 红方玩家id ~= 0 and 蓝方玩家id ~= 0 then
				local 玩家表 = {
					红方玩家id,
					蓝方玩家id
				}

				for i = 1, #玩家表 do
					发送数据(玩家数据[玩家表[i]].连接id, 128)
					常规提示(玩家表[i], "#Y/进入剑会天下PK战斗")
				end

				战斗准备类:创建玩家战斗(红方玩家id, 410005, 蓝方玩家id, 1501)
			end
		end
	end

	剑会天下单人匹配 = {}
end

function 系统处理类:剑会天下三人匹配处理()
	if 判断是否为空表(剑会天下三人匹配) then
		return
	end

	table.sort(剑会天下三人匹配, 积分排序)

	for n, v in pairs(剑会天下三人匹配) do
		if 玩家数据[v.id] ~= nil and v.匹配 and 玩家数据[v.id].战斗 == 0 and 玩家数据[v.id].观战 == nil then
			local 红方玩家id = v.id
			v.匹配 = false
			local 蓝方玩家id = 0

			if n % 2 == 1 then
				if n ~= #剑会天下三人匹配 then
					蓝方玩家id = 剑会天下三人匹配[n + 1].id or 0
					剑会天下三人匹配[n + 1].匹配 = false
				else
					local 剑会假人属性 = {}

					if 玩家数据[红方玩家id].队伍 ~= 0 then
						local 队伍id = 玩家数据[红方玩家id].队伍

						for n = 1, #队伍数据[队伍id].成员数据 do
							local 队员id = 队伍数据[队伍id].成员数据[n]

							if 玩家数据[队员id] ~= nil then
								local 武器伤害 = 0

								if 玩家数据[队员id].角色.数据.装备[3] ~= nil then
									local 临时武器 = table.loadstring(table.tostring(玩家数据[队员id].道具.数据[玩家数据[队员id].角色.数据.装备[3]]))
									武器伤害 = qz(临时武器.伤害 + 临时武器.命中 * 0.3)
								end

								剑会假人属性[#剑会假人属性 + 1] = {
									角色分类 = "角色",
									名称 = 取随机中文姓名(取随机数(2, 5)),
									模型 = 玩家数据[队员id].角色.数据.模型,
									等级 = 玩家数据[队员id].角色.数据.等级,
									气血 = 玩家数据[队员id].角色.数据.最大气血,
									魔法 = 玩家数据[队员id].角色.数据.最大魔法,
									伤害 = 玩家数据[队员id].角色.数据.伤害,
									灵力 = 玩家数据[队员id].角色.数据.灵力 + 玩家数据[队员id].角色.数据.法伤,
									速度 = 玩家数据[队员id].角色.数据.速度,
									防御 = 玩家数据[队员id].角色.数据.防御,
									法防 = 玩家数据[队员id].角色.数据.灵力 + 玩家数据[队员id].角色.数据.法防,
									攻击修炼 = 玩家数据[队员id].角色.数据.修炼.攻击修炼[1],
									法术修炼 = 玩家数据[队员id].角色.数据.修炼.法术修炼[1],
									防御修炼 = 玩家数据[队员id].角色.数据.修炼.防御修炼[1],
									抗法修炼 = 玩家数据[队员id].角色.数据.修炼.抗法修炼[1],
									门派 = 玩家数据[队员id].角色.数据.门派,
									五维属性 = {
										体质 = 玩家数据[队员id].角色.数据.体质,
										魔力 = 玩家数据[队员id].角色.数据.魔力,
										力量 = 玩家数据[队员id].角色.数据.力量,
										耐力 = 玩家数据[队员id].角色.数据.耐力,
										敏捷 = 玩家数据[队员id].角色.数据.敏捷
									},
									武器伤害 = 武器伤害,
									位置 = n
								}

								if not 判断是否为空表(玩家数据[队员id].角色.数据.参战宝宝) then
									剑会假人属性[#剑会假人属性 + 1] = {
										名称 = 玩家数据[队员id].角色.数据.参战宝宝.模型,
										模型 = 玩家数据[队员id].角色.数据.参战宝宝.模型,
										等级 = 玩家数据[队员id].角色.数据.参战宝宝.等级,
										气血 = 玩家数据[队员id].角色.数据.参战宝宝.最大气血,
										魔法 = 玩家数据[队员id].角色.数据.参战宝宝.最大魔法,
										伤害 = 玩家数据[队员id].角色.数据.参战宝宝.伤害,
										灵力 = 玩家数据[队员id].角色.数据.参战宝宝.灵力,
										速度 = 玩家数据[队员id].角色.数据.参战宝宝.速度,
										防御 = 玩家数据[队员id].角色.数据.参战宝宝.防御,
										法防 = 玩家数据[队员id].角色.数据.参战宝宝.灵力 * 0.7,
										攻击修炼 = 玩家数据[队员id].角色.数据.bb修炼.攻击控制力[1],
										法术修炼 = 玩家数据[队员id].角色.数据.bb修炼.法术控制力[1],
										防御修炼 = 玩家数据[队员id].角色.数据.bb修炼.防御控制力[1],
										抗法修炼 = 玩家数据[队员id].角色.数据.bb修炼.抗法控制力[1],
										技能 = 玩家数据[队员id].角色.数据.参战宝宝.技能,
										参战等级 = 玩家数据[队员id].角色.数据.参战宝宝.参战等级,
										五维属性 = {
											体质 = 玩家数据[队员id].角色.数据.参战宝宝.体质,
											魔力 = 玩家数据[队员id].角色.数据.参战宝宝.魔力,
											力量 = 玩家数据[队员id].角色.数据.参战宝宝.力量,
											耐力 = 玩家数据[队员id].角色.数据.参战宝宝.耐力,
											敏捷 = 玩家数据[队员id].角色.数据.参战宝宝.敏捷
										},
										位置 = n + 5
									}
								end

								发送数据(玩家数据[队员id].连接id, 128)
								常规提示(队员id, "#Y/进入剑会天下PK战斗")
							end
						end

						战斗准备类:创建战斗(红方玩家id, 110001, 0, nil, 剑会假人属性)
					end
				end
			end

			if 红方玩家id ~= 0 and 蓝方玩家id ~= 0 then
				local 队伍组 = {
					红方玩家id,
					蓝方玩家id
				}

				for i = 1, #队伍组 do
					if 玩家数据[队伍组[i]].队伍 ~= 0 then
						for n = 1, #队伍数据[玩家数据[队伍组[i]].队伍].成员数据 do
							if 玩家数据[队伍数据[玩家数据[队伍组[i]].队伍].成员数据[n]] ~= nil then
								发送数据(玩家数据[队伍数据[玩家数据[队伍组[i]].队伍].成员数据[n]].连接id, 128)
								常规提示(队伍数据[玩家数据[队伍组[i]].队伍].成员数据[n], "#Y/进入剑会天下PK战斗")
							end
						end
					end
				end

				战斗准备类:创建玩家战斗(红方玩家id, 410005, 蓝方玩家id, 1501)
			end
		end
	end

	剑会天下三人匹配 = {}
end

function 系统处理类:剑会天下五人匹配处理()
	if 判断是否为空表(剑会天下五人匹配) then
		return
	end

	table.sort(剑会天下五人匹配, 积分排序)

	for n, v in pairs(剑会天下五人匹配) do
		if 玩家数据[v.id] ~= nil and v.匹配 and 玩家数据[v.id].战斗 == 0 and 玩家数据[v.id].观战 == nil then
			local 红方玩家id = v.id
			v.匹配 = false
			local 蓝方玩家id = 0

			if n % 2 == 1 then
				if n ~= #剑会天下五人匹配 then
					蓝方玩家id = 剑会天下五人匹配[n + 1].id or 0
					剑会天下五人匹配[n + 1].匹配 = false
				else
					local 剑会假人属性 = {}

					if 玩家数据[红方玩家id].队伍 ~= 0 then
						local 队伍id = 玩家数据[红方玩家id].队伍

						for n = 1, #队伍数据[队伍id].成员数据 do
							local 队员id = 队伍数据[队伍id].成员数据[n]

							if 玩家数据[队员id] ~= nil then
								local 武器伤害 = 0

								if 玩家数据[队员id].角色.数据.装备[3] ~= nil then
									local 临时武器 = table.loadstring(table.tostring(玩家数据[队员id].道具.数据[玩家数据[队员id].角色.数据.装备[3]]))
									武器伤害 = qz(临时武器.伤害 + 临时武器.命中 * 0.3)
								end

								剑会假人属性[#剑会假人属性 + 1] = {
									角色分类 = "角色",
									名称 = 取随机中文姓名(取随机数(2, 5)),
									模型 = 玩家数据[队员id].角色.数据.模型,
									等级 = 玩家数据[队员id].角色.数据.等级,
									气血 = 玩家数据[队员id].角色.数据.最大气血,
									魔法 = 玩家数据[队员id].角色.数据.最大魔法,
									伤害 = 玩家数据[队员id].角色.数据.伤害,
									灵力 = 玩家数据[队员id].角色.数据.灵力 + 玩家数据[队员id].角色.数据.法伤,
									速度 = 玩家数据[队员id].角色.数据.速度,
									防御 = 玩家数据[队员id].角色.数据.防御,
									法防 = 玩家数据[队员id].角色.数据.灵力 + 玩家数据[队员id].角色.数据.法防,
									攻击修炼 = 玩家数据[队员id].角色.数据.修炼.攻击修炼[1],
									法术修炼 = 玩家数据[队员id].角色.数据.修炼.法术修炼[1],
									防御修炼 = 玩家数据[队员id].角色.数据.修炼.防御修炼[1],
									抗法修炼 = 玩家数据[队员id].角色.数据.修炼.抗法修炼[1],
									门派 = 玩家数据[队员id].角色.数据.门派,
									五维属性 = {
										体质 = 玩家数据[队员id].角色.数据.体质,
										魔力 = 玩家数据[队员id].角色.数据.魔力,
										力量 = 玩家数据[队员id].角色.数据.力量,
										耐力 = 玩家数据[队员id].角色.数据.耐力,
										敏捷 = 玩家数据[队员id].角色.数据.敏捷
									},
									武器伤害 = 武器伤害,
									位置 = n
								}

								if not 判断是否为空表(玩家数据[队员id].角色.数据.参战宝宝) then
									剑会假人属性[#剑会假人属性 + 1] = {
										名称 = 玩家数据[队员id].角色.数据.参战宝宝.模型,
										模型 = 玩家数据[队员id].角色.数据.参战宝宝.模型,
										等级 = 玩家数据[队员id].角色.数据.参战宝宝.等级,
										气血 = 玩家数据[队员id].角色.数据.参战宝宝.最大气血,
										魔法 = 玩家数据[队员id].角色.数据.参战宝宝.最大魔法,
										伤害 = 玩家数据[队员id].角色.数据.参战宝宝.伤害,
										灵力 = 玩家数据[队员id].角色.数据.参战宝宝.灵力,
										速度 = 玩家数据[队员id].角色.数据.参战宝宝.速度,
										防御 = 玩家数据[队员id].角色.数据.参战宝宝.防御,
										法防 = 玩家数据[队员id].角色.数据.参战宝宝.灵力 * 0.7,
										攻击修炼 = 玩家数据[队员id].角色.数据.bb修炼.攻击控制力[1],
										法术修炼 = 玩家数据[队员id].角色.数据.bb修炼.法术控制力[1],
										防御修炼 = 玩家数据[队员id].角色.数据.bb修炼.防御控制力[1],
										抗法修炼 = 玩家数据[队员id].角色.数据.bb修炼.抗法控制力[1],
										技能 = 玩家数据[队员id].角色.数据.参战宝宝.技能,
										参战等级 = 玩家数据[队员id].角色.数据.参战宝宝.参战等级,
										五维属性 = {
											体质 = 玩家数据[队员id].角色.数据.参战宝宝.体质,
											魔力 = 玩家数据[队员id].角色.数据.参战宝宝.魔力,
											力量 = 玩家数据[队员id].角色.数据.参战宝宝.力量,
											耐力 = 玩家数据[队员id].角色.数据.参战宝宝.耐力,
											敏捷 = 玩家数据[队员id].角色.数据.参战宝宝.敏捷
										},
										位置 = n + 5
									}
								end

								发送数据(玩家数据[队员id].连接id, 128)
								常规提示(队员id, "#Y/进入剑会天下PK战斗")
							end
						end

						战斗准备类:创建战斗(红方玩家id, 110001, 0, nil, 剑会假人属性)
					end
				end
			end

			if 红方玩家id ~= 0 and 蓝方玩家id ~= 0 then
				local 队伍组 = {
					红方玩家id,
					蓝方玩家id
				}

				for i = 1, #队伍组 do
					if 玩家数据[队伍组[i]].队伍 ~= 0 then
						for n = 1, #队伍数据[玩家数据[队伍组[i]].队伍].成员数据 do
							if 玩家数据[队伍数据[玩家数据[队伍组[i]].队伍].成员数据[n]] ~= nil then
								发送数据(玩家数据[队伍数据[玩家数据[队伍组[i]].队伍].成员数据[n]].连接id, 128)
								常规提示(队伍数据[玩家数据[队伍组[i]].队伍].成员数据[n], "#Y/进入剑会天下PK战斗")
							end
						end
					end
				end

				战斗准备类:创建玩家战斗(红方玩家id, 410005, 蓝方玩家id, 1501)
			end
		end
	end

	剑会天下五人匹配 = {}
end

function 系统处理类:藏宝阁取回处理(id, 编号, 类型)
	local 关键字 = "其他"

	if 类型 == 1 then
		关键字 = "装备"
	elseif 类型 == 3 then
		关键字 = "灵饰"
	elseif 类型 == 4 then
		关键字 = "召唤兽"
	elseif 类型 == 5 then
		关键字 = "银两"
	elseif 类型 == 6 then
		关键字 = "其他"
	end

	if 类型 == 7 then
		发送数据(玩家数据[id].连接id, 7, "#y/取回角色请前往XXXX取回")

		return 0
	elseif 藏宝阁数据[关键字][编号] == nil then
		发送数据(玩家数据[id].连接id, 7, "#y/数据已经刷新请重新打开藏宝阁")

		return 0
	elseif 藏宝阁数据[关键字][编号].结束时间 - os.time() <= 30 then
		发送数据(玩家数据[id].连接id, 7, "#y/该物品即将超时下架,无法进行取回处理")

		return 0
	elseif 藏宝阁数据[关键字][编号].所有者 ~= id then
		发送数据(玩家数据[id].连接id, 7, "#y/这不是你的商品你无法取回")

		return 0
	else
		if 关键字 ~= "银两" and 关键字 ~= "召唤兽" then
			self.临时格子 = 玩家数据[id].角色:取道具格子()

			if self.临时格子 == 0 then
				发送数据(玩家数据[id].连接id, 7, "#y/您当前的包裹空间已满，无法取回")

				return 0
			end

			self.可用id = 玩家数据[id].道具:取新编号()
			玩家数据[id].道具.数据[self.可用id] = 藏宝阁数据[关键字][编号].物品
			玩家数据[id].角色.数据.道具[self.临时格子] = self.可用id

			table.remove(藏宝阁数据[关键字], 编号)
			发送数据(玩家数据[id].连接id, 7, "#y/取回物品成功")
		elseif 关键字 == "银两" then
			玩家数据[id].角色:添加银子(藏宝阁数据[关键字][编号].数额, "藏宝阁取回" .. 关键字, 1)
			table.remove(藏宝阁数据[关键字], 编号)
			发送数据(玩家数据[id].连接id, 7, "#y/恭喜你取回物品成功")
		elseif 关键字 == "召唤兽" then
			if 玩家数据[id].角色.数据.召唤兽携带数量 <= #玩家数据[id].召唤兽.数据 then
				发送数据(玩家数据[id].连接id, 7, "#y/您的召唤兽空间已满，无法取回")

				return 0
			else
				玩家数据[id].召唤兽.数据[#玩家数据[id].召唤兽.数据 + 1] = 藏宝阁数据[关键字][编号].召唤兽

				table.remove(藏宝阁数据[关键字], 编号)
				发送数据(玩家数据[id].连接id, 7, "#y/恭喜你取回物品成功")
			end
		end

		for i, v in pairs(观察藏宝阁数据) do
			if 玩家数据[i] ~= nil then
				发送数据(玩家数据[i].连接id, 116, 藏宝阁数据)
			else
				观察藏宝阁数据[i] = nil
			end
		end
	end
end

function 系统处理类:藏宝阁购买处理(id, 编号, 类型)
	local 关键字 = "其他"

	if 类型 == 1 then
		关键字 = "装备"
	elseif 类型 == 3 then
		关键字 = "灵饰"
	elseif 类型 == 4 then
		关键字 = "召唤兽"
	elseif 类型 == 5 then
		关键字 = "银两"
	elseif 类型 == 6 then
		关键字 = "其他"
	elseif 类型 == 7 then
		关键字 = "角色"
	end

	if 藏宝阁数据[关键字][编号] == nil then
		发送数据(玩家数据[id].连接id, 7, "#y/数据已经刷新请重新打开藏宝阁")

		return 0
	elseif 藏宝阁数据[关键字][编号].结束时间 - os.time() <= 30 then
		发送数据(玩家数据[id].连接id, 7, "#y/该物品即将超时下架,无法进行购买处理")

		return 0
	else
		local 价格 = tonumber(藏宝阁数据[关键字][编号].价格)

		if 价格 == nil then
			return
		end

		local 买家价格 = math.floor(价格)

		if 取银子(id) < 买家价格 then
			常规提示(id, "银子不够哦!!无法购买!!!")

			return
		end

		local 对方id = 藏宝阁数据[关键字][编号].所有者

		if 关键字 ~= "银两" and 关键字 ~= "召唤兽" and 关键字 ~= "角色" then
			self.临时格子 = 玩家数据[id].角色:取道具格子()

			if self.临时格子 == 0 then
				发送数据(玩家数据[id].连接id, 7, "#y/您当前的包裹空间已满，无法购买")

				return 0
			end

			self.可用id = 玩家数据[id].道具:取新编号()
			玩家数据[id].道具.数据[self.可用id] = 藏宝阁数据[关键字][编号].物品
			玩家数据[id].角色.数据.道具[self.临时格子] = self.可用id
			藏宝阁记录 = 藏宝阁记录 .. "id:" .. id .. 玩家数据[id].角色.数据.名称 .. "通过藏宝阁购买ID:" .. 藏宝阁数据[关键字][编号].所有者 .. "物品[" .. 藏宝阁数据[关键字][编号].物品.名称 .. "*" .. tostring(藏宝阁数据[关键字][编号].物品.数量 or 1) .. "]花费" .. 价格 .. "银两\n"

			table.remove(藏宝阁数据[关键字], 编号)
			发送数据(玩家数据[id].连接id, 7, "#y/恭喜你购买物品成功")
		elseif 关键字 == "银两" then
			玩家数据[id].角色:添加银子(藏宝阁数据[关键字][编号].数额, "藏宝阁购买" .. 关键字, 1)

			藏宝阁记录 = 藏宝阁记录 .. "id:" .. id .. 玩家数据[id].角色.数据.名称 .. "通过藏宝阁购买ID:" .. 藏宝阁数据[关键字][编号].所有者 .. "物品[" .. 藏宝阁数据[关键字][编号].数额 .. "两银子]花费" .. 价格 .. "银两\n"

			table.remove(藏宝阁数据[关键字], 编号)
			发送数据(玩家数据[id].连接id, 7, "#y/恭喜你购买物品成功")
		elseif 关键字 == "召唤兽" then
			if 玩家数据[id].角色.数据.召唤兽携带数量 <= #玩家数据[id].召唤兽.数据 then
				发送数据(玩家数据[id].连接id, 7, "#y/您的召唤兽空间已满，无法购买")

				return 0
			else
				玩家数据[id].召唤兽.数据[#玩家数据[id].召唤兽.数据 + 1] = 藏宝阁数据[关键字][编号].召唤兽
				藏宝阁记录 = 藏宝阁记录 .. "id:" .. id .. 玩家数据[id].角色.数据.名称 .. "通过藏宝阁购买ID:" .. 藏宝阁数据[关键字][编号].所有者 .. "物品[" .. 藏宝阁数据[关键字][编号].召唤兽.名称 .. "]花费" .. 价格 .. "银两\n"

				table.remove(藏宝阁数据[关键字], 编号)
				发送数据(玩家数据[id].连接id, 7, "#y/恭喜你购买物品成功")
			end
		elseif 关键字 == "角色" then
			local 账号信息 = table.loadstring(读入文件("data/" .. 玩家数据[id].角色.数据.账号 .. "/信息.txt"))

			if #账号信息 >= 6 then
				发送数据(玩家数据[id].连接id, 7, "#y/您的账号信息已满,无法购买新的角色")

				return
			elseif 玩家数据[id].角色.数据.账号 == 藏宝阁数据[关键字][编号].角色信息.账号 then
				发送数据(玩家数据[id].连接id, 7, "#y/你不能购买自己的角色")

				return
			end

			账号信息[#账号信息 + 1] = 藏宝阁数据[关键字][编号].所有者

			写出文件("data/" .. 玩家数据[id].角色.数据.账号 .. "/" .. "/信息.txt", table.tostring(账号信息))

			账号信息 = {}
			local 账号 = 藏宝阁数据[关键字][编号].角色信息.账号
			账号信息 = table.loadstring(读入文件("data/" .. 账号 .. "/信息.txt"))

			for i = 1, #账号信息 do
				if 账号信息[i] == 藏宝阁数据[关键字][编号].所有者 or tonumber(账号信息[i]) == 藏宝阁数据[关键字][编号].所有者 then
					table.remove(账号信息, i)
				end
			end

			写出文件("data/" .. 账号 .. "/" .. "/信息.txt", table.tostring(账号信息))

			local 角色信息 = table.loadstring(读入文件("data/" .. 账号 .. "/" .. 藏宝阁数据[关键字][编号].所有者 .. "/角色.txt"))
			角色信息.账号 = 玩家数据[id].角色.数据.账号
			角色信息.藏宝阁出售 = nil

			写出文件("data/" .. 账号 .. "/" .. 藏宝阁数据[关键字][编号].所有者 .. "/角色.txt", table.tostring(角色信息))

			角色信息 = nil

			if 移动文件(账号, tostring(藏宝阁数据[关键字][编号].所有者), 玩家数据[id].角色.数据.账号) == "0" then
				藏宝阁记录 = 藏宝阁记录 .. 玩家数据[id].角色.数据.名称 .. "ID为:" .. id .. "通过藏宝阁购买ID:" .. 藏宝阁数据[关键字][编号].所有者 .. "角色花费" .. 价格 .. "银两,角色移除异常,请检查!\n"
			else
				藏宝阁记录 = 藏宝阁记录 .. 玩家数据[id].角色.数据.名称 .. "ID为:" .. id .. "通过藏宝阁购买ID:" .. 藏宝阁数据[关键字][编号].所有者 .. "角色花费" .. 价格 .. "银两,角色转换成功!\n"
			end

			table.remove(藏宝阁数据[关键字], 编号)
			发送数据(玩家数据[id].连接id, 7, "#y/恭喜你购买物品成功")
		end

		玩家数据[id].角色:扣除银子(买家价格, 0, 0, "藏宝阁购买", id)
		发送数据(玩家数据[id].连接id, 7, "#y/支付:" .. 数字转简(买家价格) .. "银子!")

		if 玩家数据[对方id] == nil then
			if 寄存数据[对方id] == nil then
				寄存数据[对方id] = {
					{
						类型 = "银子",
						数额 = 价格
					}
				}
			else
				寄存数据[对方id][#寄存数据[对方id] + 1] = {
					类型 = "银子",
					数额 = 价格
				}
			end
		else
			local 银两 = math.floor(价格 * (1 - cbg费率))

			玩家数据[对方id].角色:添加银子(银两, "藏宝阁出售" .. 玩家数据[对方id].账号, 对方id)
			发送数据(玩家数据[对方id].连接id, 7, "#y/藏宝阁物品成功出售,并获得" .. 数字转简(银两) .. "银子!!!")
		end

		for i, v in pairs(观察藏宝阁数据) do
			if 玩家数据[i] ~= nil then
				发送数据(玩家数据[i].连接id, 116, 藏宝阁数据)
			else
				观察藏宝阁数据[i] = nil
			end
		end
	end
end

function 系统处理类:藏宝阁上架召唤兽(id, 编号, 价格)
	if 玩家数据[id].召唤兽.数据[编号] == nil then
		发送数据(玩家数据[id].连接id, 7, "#y/你没有这样的召唤兽")

		return 0
	elseif 玩家数据[id].召唤兽:是否有装备(编号) then
		发送数据(玩家数据[id].连接id, 7, "#y/请将该召唤兽装备卸下后再进行交易")

		return 0
	elseif tonumber(价格) == nil or tonumber(价格) < 1 then
		发送数据(玩家数据[id].连接id, 7, "#y/请正确输入物品的价格")

		return 0
	elseif 玩家数据[id].摊位数据 ~= nil then
		发送数据(玩家数据[id].连接id, 7, "#y/摆摊不能上架藏宝阁")

		return 0
	elseif tonumber(价格) < 20 then
		发送数据(玩家数据[id].连接id, 7, "#y/银子价格不能低于20点")

		return 0
	elseif 玩家数据[id].召唤兽:是否有统御() then
		发送数据(玩家数据[id].连接id, 7, "#y/请将所有召唤兽统御效果撤除后再进行交易")

		return 0
	elseif #玩家数据[id].召唤兽.数据[编号].技能 < 7 then
		发送数据(玩家数据[id].连接id, 7, "#y/召唤兽上架技能要求最少8个")

		return 0
	elseif 玩家数据[id].召唤兽.数据[编号].不可交易 == true then
		发送数据(玩家数据[id].连接id, 7, "#y/无法上架绑定的召唤兽。")

		return 0
	elseif 玩家数据[id].角色.数据.召唤兽携带数量 < #玩家数据[id].召唤兽.数据 then
		发送数据(玩家数据[id].连接id, 7, "#Y/召唤携带数量超过" .. 玩家数据[id].角色.数据.召唤兽携带数量 .. "个无法上架,请将多余的存仓库")

		return 0
	else
		藏宝阁数据.召唤兽[#藏宝阁数据.召唤兽 + 1] = {
			召唤兽 = 玩家数据[id].召唤兽.数据[编号],
			价格 = 价格,
			所有者 = id,
			结束时间 = os.time() + 604800
		}

		if 玩家数据[id].召唤兽.数据[编号].认证码 == 玩家数据[id].角色.数据.参战宝宝.认证码 then
			玩家数据[id].角色.数据.参战宝宝 = {}

			发送数据(玩家数据[id].连接id, 18, 玩家数据[id].角色.数据.参战宝宝)
		end

		发送数据(玩家数据[id].连接id, 45, 编号)
		table.remove(玩家数据[id].召唤兽.数据, 编号)
		发送数据(玩家数据[id].连接id, 7, "#y/上架成功")

		for i, v in pairs(观察藏宝阁数据) do
			if 玩家数据[i] ~= nil then
				发送数据(玩家数据[i].连接id, 116, 藏宝阁数据)
			else
				观察藏宝阁数据[i] = nil
			end
		end
	end
end

function 系统处理类:藏宝阁上架(id, 编号, 价格)
	local 物品id = 玩家数据[id].角色.数据.道具[编号]
	local 道具类型 = 玩家数据[id].道具.数据[物品id].分类
	local 类型 = "其他"

	if 玩家数据[id].角色.数据.道具[编号] == nil then
		发送数据(玩家数据[id].连接id, 7, "#y/你没有这样的道具")

		return 0
	elseif 玩家数据[id].摊位数据 ~= nil then
		发送数据(玩家数据[id].连接id, 7, "#y/摆摊不能上架藏宝阁")

		return 0
	elseif 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]] == nil then
		发送数据(玩家数据[id].连接id, 7, "#y/出售的物品不存在")

		return 0
	elseif tonumber(价格) == nil or tonumber(价格) < 1 then
		发送数据(玩家数据[id].连接id, 7, "#y/请正确输入物品的价格")

		return 0
	elseif 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].不可交易 == true then
		发送数据(玩家数据[id].连接id, 7, "#y/无法上架不可交易的物品。")

		return 0
	elseif 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "飞行符" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "摄妖香" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "珍珠" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "天眼通符" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "金柳露" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "超级金柳露" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "玄武石" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "青龙石" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "白虎石" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "朱雀石" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "海马" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "秘制红罗羹" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "秘制绿罗羹" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "洞冥草" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "月华露" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "修炼果" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "九转金丹" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "易经丹" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "玉葫灵髓" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "清灵净瓶" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "彩果" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "金银锦盒" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "空白强化符" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "碎星锤" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "神兵图鉴" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "灵宝图鉴" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "含沙射影" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "符石卷轴" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "召唤兽内丹" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "元宵" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "低级清灵净瓶" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "中级清灵净瓶" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "百炼精铁" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "魔兽要诀" or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "九转金丹" then
		发送数据(玩家数据[id].连接id, 7, "#y/请勿上架低价值的物品")

		return 0
	elseif 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].总类 == 1 and 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].子类 == 20 then
		发送数据(玩家数据[id].连接id, 7, "#y/请勿上架低价值的物品")

		return 0
	elseif 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].总类 == 1 and 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].子类 == 1 then
		发送数据(玩家数据[id].连接id, 7, "#y/请勿上架低价值的物品")

		return 0
	elseif 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].总类 == 55 and 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].子类 == 1 then
		发送数据(玩家数据[id].连接id, 7, "#y/请勿上架低价值的物品")

		return 0
	elseif 玩家数据[id].道具.数据[物品id].总类 == 2 and 道具类型 >= 1 and 道具类型 <= 6 and 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].级别限制 < 40 then
		发送数据(玩家数据[id].连接id, 7, "#y/低于40的装备属于低价值物品,无法上架藏宝阁")

		return 0
	elseif 玩家数据[id].道具.数据[物品id].总类 == 2 and 道具类型 >= 10 and 道具类型 <= 13 and 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].级别限制 < 60 then
		发送数据(玩家数据[id].连接id, 7, "#y/低于60的灵饰属于低价值物品,无法上架藏宝阁")

		return 0
	elseif 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].专用 ~= nil then
		玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].专用 = id
		玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].不可交易 = true

		发送数据(玩家数据[id].连接id, 7, "#y/专用装备你上架个毛啊？")

		return 0
	else
		if 道具类型 ~= nil then
			if 玩家数据[id].道具.数据[物品id].总类 == 2 and 道具类型 >= 1 and 道具类型 <= 6 then
				类型 = "装备"
			elseif 玩家数据[id].道具.数据[物品id].总类 == 2 and 道具类型 >= 10 and 道具类型 <= 13 then
				类型 = "灵饰"
			end
		end

		藏宝阁数据[类型][#藏宝阁数据[类型] + 1] = {
			物品 = 玩家数据[id].道具.数据[物品id],
			价格 = 价格,
			所有者 = id,
			结束时间 = os.time() + 604800
		}
		玩家数据[id].角色.数据.道具[编号] = nil
		玩家数据[id].道具.数据[物品id] = nil

		刷新道具行囊单格(id, "道具", 编号, nil)
		发送数据(玩家数据[id].连接id, 7, "#y/上架成功")

		for i, v in pairs(观察藏宝阁数据) do
			if 玩家数据[i] ~= nil then
				发送数据(玩家数据[i].连接id, 116, 藏宝阁数据)
			else
				观察藏宝阁数据[i] = nil
			end
		end
	end
end

function 系统处理类:藏宝阁上架银两(id, 数量, 价格)
	if tonumber(数量) == nil or tonumber(价格) == nil then
		return
	end

	if 取银子(id) < 数量 then
		发送数据(玩家数据[id].连接id, 7, "#y/你没那么多银子")
	elseif tonumber(价格) == nil or tonumber(价格) < 1 then
		发送数据(玩家数据[id].连接id, 7, "#y/请正确输入价格")

		return 0
	elseif 玩家数据[id].摊位数据 ~= nil then
		发送数据(玩家数据[id].连接id, 7, "#y/摆摊不能上架藏宝阁")

		return 0
	else
		玩家数据[id].角色:扣除银子(数量, 0, 0, "上架藏宝阁")

		藏宝阁数据.银两[#藏宝阁数据.银两 + 1] = {
			数额 = 数量,
			价格 = 价格,
			所有者 = id,
			结束时间 = os.time() + 604800
		}

		发送数据(玩家数据[id].连接id, 7, "#y/上架成功")

		for i, v in pairs(观察藏宝阁数据) do
			if 玩家数据[i] ~= nil then
				发送数据(玩家数据[i].连接id, 116, 藏宝阁数据)
			else
				观察藏宝阁数据[i] = nil
			end
		end
	end
end

function 系统处理类:获取商店变异召唤兽(id)
	if 变异商店bb[id] == nil then
		self:刷新商店变异召唤兽(id)

		变异商店bb[id].刷新 = 0
	end

	发送数据(玩家数据[id].连接id, 130.1, 变异商店bb[id])
end

function 系统处理类:刷新商店变异召唤兽(id)
	变异商店bb[id] = {}

	for n = 1, 100 do
		local 模型 = 取随机怪(0, 105)
		变异商店bb[id][n] = {
			模型 = 模型[2],
			价格 = 取随机数(1000000, 3000000)
		}
	end
end

function 系统处理类:获取商店召唤兽(id)
	if 商店bb[id] == nil then
		self:刷新商店召唤兽(id)

		商店bb[id].刷新 = 0
	end

	发送数据(玩家数据[id].连接id, 130, 商店bb[id])
end

function 系统处理类:刷新商店召唤兽(id)
	商店bb[id] = {}

	for n = 1, 100 do
		local 模型 = 取随机怪(0, 105)
		商店bb[id][n] = {
			模型 = 模型[2],
			价格 = 取随机数(10000, 100000)
		}
	end
end

function 系统处理类:打开交易中心(id)
	local 分类信息 = {}

	table.insert(分类信息, {
		交易中心标签[1][1],
		交易中心标签[1][2],
		交易中心标签[1][3],
		交易中心标签[1][4],
		交易中心标签[1][5],
		交易中心标签[1][6]
	})
	table.insert(分类信息, {
		交易中心标签[2][1],
		交易中心标签[2][2],
		交易中心标签[2][3],
		交易中心标签[2][4],
		交易中心标签[2][5],
		交易中心标签[2][6]
	})
	table.insert(分类信息, {
		交易中心标签[3][1],
		交易中心标签[3][2],
		交易中心标签[3][3],
		交易中心标签[3][4],
		交易中心标签[3][5],
		交易中心标签[3][6]
	})
	table.insert(分类信息, {
		交易中心标签[4][1],
		交易中心标签[4][2],
		交易中心标签[4][3],
		交易中心标签[4][4],
		交易中心标签[4][5],
		交易中心标签[4][6]
	})
	table.insert(分类信息, {
		交易中心标签[5][1],
		交易中心标签[5][2],
		交易中心标签[5][3],
		交易中心标签[5][4],
		交易中心标签[5][5],
		交易中心标签[5][6]
	})
	发送数据(玩家数据[id].连接id, 3910, 分类信息)
end

function 系统处理类:刷新交易数据(id, 内容)
	local 大类 = 内容.大类 + 0
	local 小类 = 内容.小类
	local 商品列表, 小类序号 = 获取交易中心列表(大类, 小类)

	发送数据(玩家数据[id].连接id, 3911, 商品列表)
end

function 系统处理类:购买交易中心商品(id, 内容)
	local 大类 = 内容.大类 + 0
	local 小类 = 内容.小类
	local 编号 = 内容.编号 + 0
	local 商品列表, 小类序号 = 获取交易中心列表(大类, 小类)
	local 选中商品 = 商品列表[编号]
	local 商品名称提示 = ""

	if 选中商品.日涨跌幅 >= 10 then
		选中商品.日涨跌幅 = 0
	end

	local 购买数量 = (内容.数量 or 1) + 0
	local 购买价格 = 选中商品.价格
	local 跌涨 = 选中商品.日涨跌幅 + 0
	local 初始价格 = qz(选中商品.价格 / (100 + 跌涨) * 100)
	local jg = 0
	跌涨 = 跌涨 + 0.25

	if 购买数量 > 1 then
		for i = 2, 购买数量 do
			if 跌涨 >= 10 then
				跌涨 = 0
				初始价格 = qz(初始价格 * 1.1)
			end

			jg = qz(初始价格 * (100 + 跌涨) / 100)
			购买价格 = 购买价格 + jg
			跌涨 = 跌涨 + 0.25
		end
	end

	if 玩家数据[id].角色.数据.银子 < 购买价格 then
		常规提示(id, "#Y/你没有#R" .. 数字转简(购买价格) .. "#Y那么多的银子")

		return
	end

	local 临时格子 = 玩家数据[id].角色:取道具格子()

	if 临时格子 == 0 then
		常规提示(id, "#Y/包裹已满，请先整理下包裹吧！")

		return
	end

	获取道具模式[id] = 2
	道具购买价格列表[id] = qz(购买价格 / 购买数量)

	if 选中商品.名称 == "魔兽要诀" or 选中商品.名称 == "高级魔兽要诀" or 选中商品.名称 == "特殊魔兽要诀" then
		玩家数据[id].道具:给予道具(id, 选中商品.名称, 购买数量, 选中商品.参数一)

		商品名称提示 = "(" .. 选中商品.参数一 .. ")"
	elseif 选中商品.名称 == "制造指南书" then
		玩家数据[id].道具:给予道具(id, 选中商品.名称, 选中商品.参数一 + 0, 选中商品.参数二 + 0, nil, nil, {
			数量 = 购买数量
		})

		商品名称提示 = "(" .. 选中商品.参数一 .. "级)"
	elseif 选中商品.名称 == "百炼精铁" then
		玩家数据[id].道具:给予道具(id, 选中商品.名称, 选中商品.参数一 + 0, nil, nil, nil, {
			数量 = 购买数量
		})

		商品名称提示 = "(" .. 选中商品.参数一 .. "级)"
	elseif 选中商品.名称 == "元灵晶石" then
		玩家数据[id].道具:给予道具(id, 选中商品.名称, {
			选中商品.参数一 / 10
		}, nil, nil, nil, {
			数量 = 购买数量
		})

		商品名称提示 = "(" .. 选中商品.参数一 .. "级)"
	elseif 选中商品.名称 == "灵饰指南书" then
		玩家数据[id].道具:给予道具(id, 选中商品.名称, {
			选中商品.参数一 / 10
		}, 选中商品.参数二, nil, nil, {
			数量 = 购买数量
		})

		商品名称提示 = "(" .. 选中商品.参数一 .. "级)"
	elseif 宝石列表1[选中商品.名称] ~= nil then
		玩家数据[id].道具:给予道具(id, 选中商品.名称, 选中商品.参数一, 购买数量)

		商品名称提示 = "(" .. 选中商品.参数一 .. "级)"
	elseif 选中商品.参数一类型 == "召唤兽" then
		获取道具模式[id] = nil
		local lx = 选中商品.参数一

		if 玩家数据[id].角色:取新增宝宝数量() then
			玩家数据[id].召唤兽:添加召唤兽(选中商品.名称, lx)
		else
			常规提示(id, "#Y/无法携带更多召唤兽，购买失败！")

			return
		end
	else
		玩家数据[id].道具:给予道具(id, 选中商品.名称, 购买数量)
	end

	获取道具模式[id] = nil

	玩家数据[id].角色:扣除银子(购买价格, 0, 0, "交易中心购买", 1)
	玩家数据[id].角色:日志记录(format("[交易中心-购买]购买道具[%s][%s][%s个]，花费%s两银子：[%s][%s][%s]", 选中商品.名称, 选中商品.参数一, 购买数量, 购买价格, 玩家数据[id].账号, id, 玩家数据[id].角色.名称))
	常规提示(id, "#Y/你花费了#R" .. 数字转简(购买价格) .. "#Y两，成功购买了#R" .. 选中商品.名称 .. 商品名称提示 .. "#Y*#R" .. 购买数量 .. "#Y！")

	交易中心[大类][小类序号].内容[编号].价格 = qz(初始价格 * (100 + 跌涨) / 100)
	交易中心[大类][小类序号].内容[编号].日涨跌幅 = 跌涨
	道具购买价格列表[id] = nil

	发送数据(玩家数据[id].连接id, 3911, 商品列表)
	刷新货币(玩家数据[id].连接id, id)
end

function 系统处理类:出售交易中心商品(id, 内容)
	local 大类 = 内容.大类 + 0
	local 小类 = 内容.小类
	local 编号 = 内容.编号 + 0
	local 商品列表, 小类序号 = 获取交易中心列表(大类, 小类)
	local 选中商品 = 商品列表[编号]
	local 出售价格比例 = 0.6
	local 宝石 = false

	if 选中商品.日涨跌幅 <= -10 then
		选中商品.日涨跌幅 = 0
	end

	if 选中商品.参数一类型 == "召唤兽" then
		if 商品列表[1].名称 == "日游神" then
			常规提示(id, "该页召唤兽不允许出售。")

			return
		end

		local bbmc = 选中商品.名称
		local 出售bb = 0

		for i = 1, #玩家数据[id].召唤兽.数据 do
			local bb = 玩家数据[id].召唤兽.数据[i]

			if bb.模型 == bbmc and bb.名称 == bbmc and 参战信息 == nil and 助战参战 == nil and (bb.装备 == nil or 判断是否为空表(bb.装备)) then
				出售bb = i

				break
			end
		end

		if 出售bb > 0 then
			local 出售价格 = math.floor(选中商品.价格 * 出售价格比例)
			交易中心[大类][小类序号].内容[编号].价格 = math.max(math.floor(交易中心[大类][小类序号].内容[编号].价格 / (100 + 交易中心[大类][小类序号].内容[编号].日涨跌幅) * (100 + 交易中心[大类][小类序号].内容[编号].日涨跌幅 - 0.25)), 交易中心[大类][小类序号].内容[编号].最低价格 or 100)
			交易中心[大类][小类序号].内容[编号].日涨跌幅 = 交易中心[大类][小类序号].内容[编号].日涨跌幅 - 0.25

			常规提示(id, "#Y出售#R" .. bbmc .. "#Y成功，你获得了#R" .. 出售价格 .. "#Y两银子")
			玩家数据[id].角色:添加银子(出售价格, "交易中心出售", 1)
			玩家数据[id].召唤兽:出售处理(玩家数据[id].连接id, id, 出售bb)
			刷新货币(玩家数据[id].连接id, id)
		else
			常规提示(id, "出售失败，你身上没有#R" .. bbmc .. "#Y召唤兽。")
		end
	else
		local 出售数量 = (内容.数量 or 1) + 0

		if 宝石列表1[选中商品.名称] ~= nil then
			宝石 = true
			出售数量 = 1
		end

		local 扣除成功 = 玩家数据[id].道具:扣除道具数量(id, 选中商品.名称, 出售数量, 选中商品.参数一类型, 选中商品.参数一, 选中商品.参数二类型, 选中商品.参数二, 宝石)

		if 扣除成功 then
			if 宝石 == true and 选中商品.参数一类型 == "级别限制" then
				常规提示(id, "#Y你出售了#G" .. 出售宝石等级[id] + 选中商品.参数一 - 1 .. "级" .. 选中商品.名称)

				if 选中商品.名称 == "星辉石" then
					出售数量 = 3^(出售宝石等级[id] - 1)
				else
					出售数量 = 2^(出售宝石等级[id] - 1)
				end

				if 道具出售价格列表[id] ~= nil then
					道具出售价格列表[id].数量 = 出售数量 + 0
				end
			end

			local 出售价格 = 0
			local 跌涨 = 选中商品.日涨跌幅 + 0
			local 初始价格 = math.max(qz(选中商品.价格 / (100 + 跌涨) * 100), 选中商品.最低价格 or 100)

			if 道具出售价格列表[id] ~= nil then
				local jg = 0

				for i = 1, 道具出售价格列表[id].数量 do
					if 跌涨 <= -10 then
						跌涨 = 0
						初始价格 = math.max(qz(初始价格 * 0.9), 选中商品.最低价格 or 100)
					end

					jg = math.max(qz(初始价格 * (100 + 跌涨) / 100), 选中商品.最低价格 or 100)
					跌涨 = 跌涨 - 0.25
					出售价格 = 出售价格 + jg
				end

				出售价格 = math.min(道具出售价格列表[id].价格, 出售价格)
				出售数量 = 出售数量 - 道具出售价格列表[id].数量
			end

			if 出售数量 > 0 then
				local jg = 0

				for i = 1, 出售数量 do
					if 跌涨 <= -10 then
						跌涨 = 0
						初始价格 = math.max(qz(初始价格 * 0.9), 选中商品.最低价格 or 100)
					end

					jg = math.max(qz(初始价格 * (100 + 跌涨) / 100), 选中商品.最低价格 or 100)
					跌涨 = 跌涨 - 0.25
					出售价格 = 出售价格 + jg
				end
			end

			交易中心[大类][小类序号].内容[编号].价格 = math.max(qz(初始价格 * (100 + 跌涨) / 100), 选中商品.最低价格 or 100)
			交易中心[大类][小类序号].内容[编号].日涨跌幅 = 跌涨
			出售价格 = qz(出售价格 * 出售价格比例)

			常规提示(id, "#Y出售成功，你获得了#R" .. 数字转简(出售价格) .. "#Y两银子")
			玩家数据[id].角色:添加银子(出售价格, "交易中心出售", 1)
			刷新货币(玩家数据[id].连接id, id)
		else
			常规提示(id, "出售失败，你没有这个道具")
		end
	end

	发送数据(玩家数据[id].连接id, 3911, 商品列表)
end

function 系统处理类:获取商店召唤兽(id)
	if 商店bb[id] == nil then
		self:刷新商店召唤兽(id)

		商店bb[id].刷新 = 0
	end

	发送数据(玩家数据[id].连接id, 130, 商店bb[id])
end

function 系统处理类:取消息数据(id, 连接id)
	if 玩家数据[id] ~= nil and 消息数据[id] ~= nil and #消息数据[id] > 0 then
		local 接收消息 = true

		发送数据(玩家数据[id].连接id, 58, {
			信息 = 消息数据[id][1].名称 .. "   " .. 消息数据[id][1].时间,
			模型 = 消息数据[id][1].模型,
			类型 = 消息数据[id][1].类型,
			id = 消息数据[id][1].id,
			内容 = 消息数据[id][1].内容,
			名称 = 消息数据[id][1].名称,
			好友度 = 消息数据[id][1].好友度,
			等级 = 消息数据[id][1].等级
		})
		table.remove(消息数据[id], 1)

		if #消息数据[id] == 0 then
			发送数据(玩家数据[id].连接id, 57, "1")
		end

		return true
	else
		发送数据(玩家数据[id].连接id, 57, "1")

		return false
	end
end

function 系统处理类:拒收消息检查(id, 好友id, 提示id)
	if 好友黑名单[id] == nil then
		好友黑名单[id] = {}
	end

	for n = 1, #好友黑名单[id] do
		if 好友黑名单[id][n] == 好友id then
			常规提示(提示id, "#Y你已被对方拉入黑名单中！")

			return false
		end
	end

	return true
end

function 系统处理类:更新消息通知(id)
	if 玩家数据[id] ~= nil and 消息数据[id] ~= nil and #消息数据[id] > 0 then
		发送数据(玩家数据[id].连接id, 56, "1")
	end

	if 玩家数据[id] ~= nil and 玩家数据[id].摊位数据 ~= nil then
		玩家数据[id].摊位数据 = nil

		地图处理类:取消玩家摊位(id)
	end
end

function 系统处理类:取好友度(id, 好友id)
	for n = 1, #玩家数据[id].角色.数据.好友数据.好友 do
		if 玩家数据[id].角色.数据.好友数据.好友[n].id == 好友id then
			if 玩家数据[id].角色.数据.好友数据.好友[n].好友度 == nil then
				return 0
			else
				return 玩家数据[id].角色.数据.好友数据.好友[n].好友度
			end
		end
	end

	return 0
end

function 系统处理类:添加好友(id, 连接id, 好友id, 类型)
	if id == 好友id then
		常规提示(id, "#Y你无法将自己添加到好友名单中")

		return
	end

	if 类型 == 1 then
		if #玩家数据[id].角色.数据.好友数据.好友 >= 50 then
			常规提示(id, "#Y你的好友人数已达上限")

			return
		else
			for n = 1, #玩家数据[id].角色.数据.好友数据.好友 do
				if 玩家数据[id].角色.数据.好友数据.好友[n].id == 好友id then
					常规提示(id, "#Y对方已经在你的好友名单中了")

					return
				end
			end

			local 删除序列 = 0

			for n = 1, #玩家数据[id].角色.数据.好友数据.黑名单 do
				if 玩家数据[id].角色.数据.好友数据.黑名单[n].id == 好友id then
					删除序列 = n
				end
			end

			if 删除序列 ~= 0 then
				table.remove(玩家数据[id].角色.数据.好友数据.黑名单, 删除序列)
			end
		end

		玩家数据[id].角色.数据.好友数据.好友[#玩家数据[id].角色.数据.好友数据.好友 + 1] = {
			关系 = "陌生人",
			模型 = 玩家数据[好友id].角色.数据.模型,
			名称 = 玩家数据[好友id].角色.数据.名称,
			id = 好友id,
			门派 = 玩家数据[好友id].角色.数据.门派,
			帮派 = 玩家数据[好友id].角色.数据.帮派,
			等级 = 玩家数据[好友id].角色.数据.等级,
			称谓 = 玩家数据[好友id].角色.数据.当前称谓
		}

		for n = 1, #玩家数据[好友id].角色.数据.好友数据.好友 do
			if 玩家数据[好友id].角色.数据.好友数据.好友[n].id == id then
				if 玩家数据[好友id].角色.数据.好友数据.好友[n].好友度 ~= nil then
					玩家数据[id].角色.数据.好友数据.好友[#玩家数据[id].角色.数据.好友数据.好友].好友度 = 玩家数据[好友id].角色.数据.好友数据.好友[n].好友度
				end

				玩家数据[好友id].角色.数据.好友数据.好友[n].关系 = "普通朋友"
				玩家数据[id].角色.数据.好友数据.好友[#玩家数据[id].角色.数据.好友数据.好友].关系 = "普通朋友"
			end
		end

		常规提示(id, "#Y添加好友成功")
		常规提示(好友id, "#Y" .. 玩家数据[id].角色.数据.名称 .. "将你添加为好友")

		local 删除序列 = 0

		for n = 1, #玩家数据[id].角色.数据.好友数据.临时 do
			if 玩家数据[id].角色.数据.好友数据.临时[n].id == 好友id then
				删除序列 = n
			end
		end

		if 删除序列 ~= 0 then
			table.remove(玩家数据[id].角色.数据.好友数据.临时, 删除序列)
		end

		发送数据(连接id, 52)

		if 玩家数据[id].角色.数据.好友数据.好友[#玩家数据[id].角色.数据.好友数据.好友].关系 ~= "陌生人" then
			发送数据(玩家数据[好友id].连接id, 52)
		end
	elseif 类型 == 2 then
		for n = 1, #玩家数据[id].角色.数据.好友数据.好友 do
			if 玩家数据[id].角色.数据.好友数据.好友[n].id == 好友id then
				常规提示(id, "#Y对方已经在你的好友名单中了")

				return
			end
		end

		for n = 1, #玩家数据[id].角色.数据.好友数据.临时 do
			if 玩家数据[id].角色.数据.好友数据.临时[n].id == 好友id then
				常规提示(id, "#Y对方已经在你的临时好友名单中了")

				return
			end
		end

		local 序列 = 0

		if #玩家数据[id].角色.数据.好友数据.临时 < 6 then
			序列 = #玩家数据[id].角色.数据.好友数据.临时 + 1
		else
			table.remove(玩家数据[id].角色.数据.好友数据.临时, 1)

			序列 = 6
		end

		玩家数据[id].角色.数据.好友数据.临时[序列] = {
			关系 = "陌生人",
			模型 = 玩家数据[好友id].角色.数据.模型,
			名称 = 玩家数据[好友id].角色.数据.名称,
			id = 好友id,
			门派 = 玩家数据[好友id].角色.数据.门派,
			帮派 = 玩家数据[好友id].角色.数据.帮派,
			等级 = 玩家数据[好友id].角色.数据.等级,
			称谓 = 玩家数据[好友id].角色.数据.当前称谓
		}

		常规提示(id, "#Y添加临时好友成功")
		发送数据(连接id, 52)
	elseif 类型 == 3 then
		for n = 1, #玩家数据[id].角色.数据.好友数据.黑名单 do
			if 玩家数据[id].角色.数据.好友数据.黑名单[n].id == 好友id then
				常规提示(id, "#Y对方已经在你的黑名单中了")

				return
			end
		end

		if #玩家数据[id].角色.数据.好友数据.黑名单 >= 20 then
			常规提示(id, "#Y你的黑名单人数已达上限")

			return
		end

		玩家数据[id].角色.数据.好友数据.黑名单[#玩家数据[id].角色.数据.好友数据.黑名单 + 1] = {
			关系 = "黑名单",
			模型 = 玩家数据[好友id].角色.数据.模型,
			名称 = 玩家数据[好友id].角色.数据.名称,
			id = 好友id,
			门派 = 玩家数据[好友id].角色.数据.门派,
			帮派 = 玩家数据[好友id].角色.数据.帮派,
			等级 = 玩家数据[好友id].角色.数据.等级,
			称谓 = 玩家数据[好友id].角色.数据.当前称谓
		}
		好友黑名单[id][#好友黑名单[id] + 1] = 好友id

		常规提示(id, "#Y添加黑名单成功")

		local 删除序列 = 0

		for n = 1, #玩家数据[id].角色.数据.好友数据.好友 do
			if 玩家数据[id].角色.数据.好友数据.好友[n].id == 好友id then
				删除序列 = n
			end
		end

		if 删除序列 ~= 0 then
			table.remove(玩家数据[id].角色.数据.好友数据.好友, 删除序列)
		end

		删除序列 = 0

		for n = 1, #玩家数据[id].角色.数据.好友数据.临时 do
			if 玩家数据[id].角色.数据.好友数据.临时[n].id == 好友id then
				删除序列 = n
			end
		end

		if 删除序列 ~= 0 then
			table.remove(玩家数据[id].角色.数据.好友数据.临时, 删除序列)
		end

		删除序列 = 0

		for n = 1, #玩家数据[id].角色.数据.好友数据.最近 do
			if 玩家数据[id].角色.数据.好友数据.最近[n].id == 好友id then
				删除序列 = n
			end
		end

		if 删除序列 ~= 0 then
			table.remove(玩家数据[id].角色.数据.好友数据.最近, 删除序列)
		end

		发送数据(连接id, 52)
	end
end

function 系统处理类:查找角色(名称, id)
	local 数据组 = {}

	if id ~= "" then
		id = id + 0
	end

	for i, v in pairs(玩家数据) do
		if 玩家数据[i].管理 == nil and 玩家数据[i].角色.数据.名称 == 名称 or i == id then
			数据组[1] = 玩家数据[i].角色.数据.名称
			数据组[2] = i
			数据组[3] = 玩家数据[i].角色.数据.等级
			数据组[4] = 玩家数据[i].角色.数据.门派
		end
	end

	return 数据组
end

function 系统处理类:断开游戏(数字id, id)
	if id ~= nil then
		数字id = 数字id or id

		if 玩家数据[数字id] == nil or id ~= 玩家数据[数字id].连接id then
			return
		end
	end

	if 玩家数据[数字id] == nil then
		return
	end

	if 玩家数据[数字id].摊位数据 ~= nil then
		return
	end

	if 玩家数据[数字id].管理 ~= nil then
		玩家数据[数字id] = nil

		return
	end

	if 玩家数据[数字id] ~= nil and 玩家数据[数字id].战斗 ~= 0 then
		if 战斗准备类.战斗盒子[玩家数据[数字id].战斗] ~= nil and 玩家数据[数字id].观战 == nil then
			战斗准备类.战斗盒子[玩家数据[数字id].战斗]:设置断线玩家(数字id)

			return
		elseif 战斗准备类.战斗盒子[玩家数据[数字id].战斗] ~= nil and 玩家数据[数字id].观战 ~= nil then
			战斗准备类.战斗盒子[玩家数据[数字id].战斗][数字id] = nil
			玩家数据[数字id].战斗 = 0
		else
			玩家数据[数字id].战斗 = 0
		end
	end

	if 玩家数据[数字id] ~= nil then
		if 玩家数据[数字id].交易信息 ~= nil then
			玩家数据[数字id].道具:取消交易(数字id)
		end

		if 玩家数据[数字id].队伍 ~= 0 then
			if not 判断是否为空表(剑会天下三人匹配) then
				for i = 1, #队伍数据[玩家数据[数字id].队伍].成员数据 do
					if 玩家数据[队伍数据[玩家数据[数字id].队伍].成员数据[i]] ~= nil then
						发送数据(玩家数据[队伍数据[玩家数据[数字id].队伍].成员数据[i]].连接id, 128)
						常规提示(队伍数据[玩家数据[数字id].队伍].成员数据[i], "#Y/因为队伍玩家离开取消了匹配！")
					end
				end

				for n, v in pairs(剑会天下三人匹配) do
					if v.id == 玩家数据[数字id].队伍 then
						table.remove(剑会天下三人匹配, n)

						break
					end
				end
			end

			if not 判断是否为空表(剑会天下五人匹配) then
				for i = 1, #队伍数据[玩家数据[数字id].队伍].成员数据 do
					if 玩家数据[队伍数据[玩家数据[数字id].队伍].成员数据[i]] ~= nil then
						发送数据(玩家数据[队伍数据[玩家数据[数字id].队伍].成员数据[i]].连接id, 128)
						常规提示(队伍数据[玩家数据[数字id].队伍].成员数据[i], "#Y/因为队伍玩家离开取消了匹配！")
					end
				end

				for n, v in pairs(剑会天下五人匹配) do
					if v.id == 玩家数据[数字id].队伍 then
						table.remove(剑会天下五人匹配, n)

						break
					end
				end
			end

			队伍处理类:退出队伍(数字id)
		elseif not 判断是否为空表(剑会天下单人匹配) then
			for n, v in pairs(剑会天下单人匹配) do
				if v.id == 数字id then
					table.remove(剑会天下单人匹配, n)

					break
				end
			end
		end

		if 自动遇怪[数字id] ~= nil then
			自动遇怪[数字id] = nil
		end

		if 玩家数据[数字id].角色.数据.帮派 ~= "无帮派" and 玩家数据[数字id].角色.数据.帮派数据 ~= nil then
			local 帮派编号 = 玩家数据[数字id].角色.数据.帮派数据.编号

			if 帮派数据[帮派编号].商人 == nil then
				帮派数据[帮派编号].商人 = {}
			end

			if 帮派数据[帮派编号].成员数据[数字id] ~= nil and 帮派数据[帮派编号].成员数据[数字id].职务 == "商人" then
				for i = 1, #帮派数据[帮派编号].商人 do
					if 帮派数据[帮派编号].商人[i] ~= nil and 帮派数据[帮派编号].商人[i].id == 数字id then
						table.remove(帮派数据[帮派编号].商人, i)

						break
					end
				end

				帮派数据[帮派编号].成员数据[数字id].职务 = "帮众"

				玩家数据[数字id].角色:删除称谓(数字id, 帮派数据[帮派编号].帮派名称 .. "商人")
				玩家数据[数字id].角色:添加称谓(数字id, 帮派数据[帮派编号].帮派名称 .. "帮众")
			end

			帮派数据[帮派编号].成员数据[数字id].在线 = false
			帮派数据[帮派编号].成员数据[数字id].离线时间 = os.time()
		end

		玩家数据[数字id].角色.数据.离线时间 = os.time()

		玩家数据[数字id].角色:存档()

		if 玩家数据[数字id].账号 == nil then
			玩家数据[数字id].账号 = 玩家数据[数字id].角色.数据.账号
			账号记录[玩家数据[数字id].账号 .. 数字id] = nil
		else
			账号记录[玩家数据[数字id].账号 .. 数字id] = nil
		end

		地图处理类:移除玩家(数字id)

		玩家数据[数字id] = nil

		collectgarbage("collect")
	end
end

function 系统处理类:统计排行榜(id)
	local 名单 = {
		实力 = {},
		比武 = {},
		帮派 = {},
		财富 = {
			银子 = {},
			金额 = {}
		}
	}
	local 我的排行 = {
		实力 = {},
		比武 = {},
		帮派 = {},
		财富 = {
			银子 = {},
			金额 = {}
		}
	}
	local 发送信息 = {
		实力 = {},
		比武 = {},
		帮派 = {},
		财富 = {
			银子 = {},
			金额 = {}
		}
	}

	for b, v in pairs(经验数据.排行) do
		名单.实力[#名单.实力 + 1] = {
			经验 = 经验数据.排行[b].经验,
			id = b,
			名称 = 经验数据.排行[b].名称,
			等级 = 经验数据.排行[b].等级,
			门派 = 经验数据.排行[b].门派,
			账号 = 经验数据.排行[b].账号
		}
	end

	table.sort(名单.实力, function (a, b)
		return b.经验 < a.经验
	end)

	发送信息.比武 = 比武大会

	for b, v in pairs(银子数据) do
		名单.财富.银子[#名单.财富.银子 + 1] = {
			银子 = 银子数据[b].银子,
			id = b,
			名称 = 银子数据[b].名称,
			等级 = 银子数据[b].等级,
			门派 = 银子数据[b].门派,
			账号 = 银子数据[b].账号
		}
	end

	table.sort(名单.财富.银子, function (a, b)
		return b.银子 < a.银子
	end)

	for b, v in pairs(充值数据) do
		名单.财富.金额[#名单.财富.金额 + 1] = {
			金额 = 充值数据[b].金额,
			id = b,
			名称 = 充值数据[b].名称,
			等级 = 充值数据[b].等级,
			门派 = 充值数据[b].门派,
			账号 = 银子数据[b].账号
		}
	end

	table.sort(名单.财富.金额, function (a, b)
		return b.金额 < a.金额
	end)

	for b, v in pairs(帮派竞赛) do
		名单.帮派[#名单.帮派 + 1] = {
			帮派 = 帮派竞赛[b].帮派名称,
			id = b,
			帮主 = 帮派竞赛[b].帮主,
			id = 帮派竞赛[b].id,
			积分 = 帮派竞赛[b].积分
		}
	end

	table.sort(名单.帮派, function (a, b)
		return b.积分 < a.积分
	end)

	for i = 1, 10 do
		if 名单.实力[i] ~= nil then
			发送信息.实力[i] = 名单.实力[i]
		end

		if 名单.比武[i] ~= nil then
			发送信息.比武[i] = 名单.比武[i]
		end

		if 名单.帮派[i] ~= nil then
			发送信息.帮派[i] = 名单.帮派[i]
		end

		if 名单.财富.银子[i] ~= nil then
			发送信息.财富.银子[i] = 名单.财富.银子[i]
		end

		if 名单.财富.金额[i] ~= nil then
			发送信息.财富.金额[i] = 名单.财富.金额[i]
		end
	end

	发送信息.id = id

	发送数据(玩家数据[id].连接id, 49, 发送信息)
end

function 系统处理类:取角色选择id(id, 账号)
	if 账号 == nil or id == nil or id == 0 then
		return
	end

	local 临时id = 0

	if f函数.文件是否存在("data/" .. 账号 .. "/信息.txt") == false then
		return
	else
		local 临时文件 = 读入文件("data/" .. 账号 .. "/信息.txt")
		local 写入信息 = table.loadstring(临时文件)

		if 写入信息[id + 0] ~= nil then
			if f函数.文件是否存在("data/" .. 账号 .. "/" .. 写入信息[id + 0] .. "/角色.txt") == false then
				return
			else
				local 读取文件 = 读入文件("data/" .. 账号 .. "/" .. 写入信息[id + 0] .. "/角色.txt")
				local 还原数据 = table.loadstring(读取文件)
				临时id = 还原数据.数字id
			end
		end
	end

	return 临时id
end

给予补偿 = function(id, 账号)
	补偿领取[账号] = 1
	local 补偿说明 = {}
	local 说明 = ""

	if 补偿列表.仙玉 ~= nil then
		添加仙玉(补偿列表.仙玉, 账号, id, "系统补偿")

		补偿说明[#补偿说明 + 1] = "#R/" .. qz1(补偿列表.仙玉) .. "#G/仙玉#Y"
	end

	if 补偿列表.经验 ~= nil then
		玩家数据[id].角色.数据.当前经验 = 玩家数据[id].角色.数据.当前经验 + qz1(补偿列表.经验)
		补偿说明[#补偿说明 + 1] = "#R/" .. qz1(补偿列表.经验) .. "#G/经验#Y"
	end

	if 补偿列表.银两 ~= nil then
		玩家数据[id].角色.数据.银子 = 玩家数据[id].角色.数据.银子 + qz1(补偿列表.银两)
		补偿说明[#补偿说明 + 1] = "#R/" .. qz1(补偿列表.银两) .. "#G/两#Y"
	end

	if 补偿列表.储备 ~= nil then
		玩家数据[id].角色.数据.储备 = 玩家数据[id].角色.数据.储备 + qz1(补偿列表.储备)
		补偿说明[#补偿说明 + 1] = "#R/" .. qz1(补偿列表.储备) .. "#G/点储备#Y"
	end

	if #补偿说明 > 0 then
		for i = 1, #补偿说明 do
			if i == 1 then
				说明 = 补偿说明[i]
			else
				说明 = 说明 .. "、" .. 补偿说明[i]
			end
		end

		发送数据(玩家数据[id].连接id, 38, {
			频道 = "xt",
			内容 = "#P(停机补偿)#Y你获得了" .. 说明
		})
	end
end

重置统御 = function(数字id)
	if 玩家数据[数字id].角色.数据.坐骑列表 ~= nil then
		for i = 1, #玩家数据[数字id].角色.数据.坐骑列表 do
			玩家数据[数字id].角色.数据.坐骑列表[i].统御召唤兽 = {}
			玩家数据[数字id].角色.数据.坐骑列表[i].忠诚 = 玩家数据[数字id].角色.数据.坐骑列表[i].忠诚 or 100
		end
	end

	if 玩家数据[数字id].召唤兽.数据 ~= nil and #玩家数据[数字id].召唤兽.数据 > 0 then
		for i = 1, #玩家数据[数字id].召唤兽.数据 do
			玩家数据[数字id].召唤兽.数据[i].统御 = nil
		end
	end

	if 玩家数据[数字id].召唤兽仓库.数据 ~= nil and #玩家数据[数字id].召唤兽仓库.数据 > 0 then
		for i = 1, #玩家数据[数字id].召唤兽仓库.数据 do
			玩家数据[数字id].召唤兽仓库.数据[i].统御 = nil
		end
	end
end

function 系统处理类:取消角色自动(数字id, 掉线重连)
	if 玩家数据[数字id] ~= nil then
		if 聚宝盆上限 < (玩家数据[数字id].角色.数据.聚宝盆 or 0) then
			玩家数据[数字id].角色.数据.聚宝盆 = nil
		end

		if 通灵宝玉上限 < (玩家数据[数字id].角色.数据.通灵宝玉 or 0) then
			玩家数据[数字id].角色.数据.通灵宝玉 = nil
		end

		玩家数据[数字id].安全码验证 = nil

		if 掉线重连 == nil then
			玩家数据[数字id].角色.数据.自动捉鬼 = nil
			玩家数据[数字id].角色.数据.自动遇怪 = nil
			自动捉鬼[数字id] = nil
			自动遇怪[数字id] = nil
		end

		if 自动挂机[数字id] ~= nil then
			玩家数据[数字id].角色.数据.自动挂机 = true
		else
			玩家数据[数字id].角色.数据.自动挂机 = nil
		end

		if 自动捉鬼[数字id] ~= nil then
			玩家数据[数字id].角色.数据.自动捉鬼 = true
		else
			玩家数据[数字id].角色.数据.自动捉鬼 = nil
		end

		if 自动遇怪[数字id] ~= nil then
			玩家数据[数字id].角色.数据.自动遇怪 = true
		else
			玩家数据[数字id].角色.数据.自动遇怪 = nil
		end

		if 打造熟练度数据[数字id] == nil then
			打造熟练度数据[数字id] = {}
			玩家数据[数字id].角色.数据.打造熟练度 = 玩家数据[数字id].角色.数据.打造熟练度 or 0
			打造熟练度数据[数字id].熟练度 = 玩家数据[数字id].角色.数据.打造熟练度 + 0
			打造熟练度数据[数字id].玩家名称 = 玩家数据[数字id].角色.数据.名称
		else
			if 打造熟练度数据[数字id].玩家名称 == nil then
				玩家数据[数字id].角色.数据.打造熟练度 = 打造熟练度数据[数字id].熟练度 + (玩家数据[数字id].角色.数据.打造熟练度 or 0)
			end

			local aa = math.max(打造熟练度数据[数字id].熟练度, 玩家数据[数字id].角色.数据.打造熟练度) + 0
			打造熟练度数据[数字id].熟练度 = aa + 0
			玩家数据[数字id].角色.数据.打造熟练度 = aa + 0
			打造熟练度数据[数字id].玩家名称 = 玩家数据[数字id].角色.数据.名称
		end
	end
end

发送时辰天气 = function(id, 数字id)
	if 天气统一 then
		发送数据(id, 43, {
			时辰 = 时辰信息.当前,
			天气 = 时辰信息.天气
		})
	else
		发送数据(id, 43, {
			时辰 = 时辰信息.当前
		})

		local aa = tostring(玩家数据[数字id].角色.数据.地图数据.编号)

		if 天气地图[aa] ~= nil then
			发送数据(id, 43.1, {
				天气 = 地区天气[天气地图[aa]]
			})
		end
	end
end

function 系统处理类:进入游戏(id, 账号, 数字id, ip, 硬盘, 序号, 客户端版本, 掉线重连)
	if tostring(客户端版本) ~= tostring(版本) then
		发送数据(id, 7, "客户端版本过低，请更新1!")

		return
	elseif os.time() < 开服时间 and 管理账号列表[账号] == nil then
		发送数据(id, 7, "未开服!开服时间：" .. 开服时间1)

		return
	end

	硬盘 = tostring(硬盘)

	if 客户端登陆列表[硬盘] == nil then
		客户端登陆列表[硬盘] = {
			数字id + 0
		}
	else
		local aa = 客户端登陆列表[硬盘]

		if #aa < 限制电脑登陆 then
			aa[#aa + 1] = 数字id + 0
		else
			local 删除组 = {}

			for i = 1, #aa do
				if 玩家数据[aa[i]] == nil or aa[i] == 数字id then
					删除组[#删除组 + 1] = i + 0
				elseif 玩家数据[aa[i]].登陆电脑 ~= 硬盘 then
					删除组[#删除组 + 1] = i + 0
				end
			end

			aa = 无错误删除列表多个元素(aa, 删除组)

			if #aa < 限制电脑登陆 then
				aa[#aa + 1] = 数字id + 0
			else
				发送数据(id, 7, "此电脑可登陆角色已达上限!")

				return
			end
		end
	end

	数字id = 数字id + 0

	发送数据(id, -2, 数字id)

	if 消息数据[数字id] == nil then
		消息数据[数字id] = {}
	end

	if 好友黑名单[数字id] == nil then
		好友黑名单[数字id] = {}
	end

	if 玩家数据[数字id] ~= nil and 玩家数据[数字id].角色 ~= nil and 玩家数据[数字id].角色.数据.藏宝阁出售 == nil then
		if 玩家数据[数字id].交易信息 ~= nil then
			玩家数据[数字id].道具:取消交易(数字id)
		end

		发送数据(玩家数据[数字id].连接id, 998, "您的账号已经在其他地方登陆,如不是您本人,请及时修改密码")

		玩家数据[数字id].连接id = id

		if 玩家数据[数字id].角色.数据.地图数据.编号 >= 100000 and 玩家数据[数字id].角色.数据.地图数据.编号 <= 400000000 then
			local x = tonumber(string.sub(玩家数据[数字id].角色.数据.地图数据.编号, 2, 6))

			for i = 1, #房屋数据 do
				if 房屋数据[i].ID == x then
					发送数据(id, 111, 房屋数据[i])
				end
			end
		end

		self:取消角色自动(数字id, 掉线重连)

		if 序号 == nil then
			发送数据(id, 5, 玩家数据[数字id].角色:取总数据())
			发送数据(id, 16, 玩家数据[数字id].召唤兽.数据)
			发送数据(id, 102, 玩家数据[数字id].助战:取数据())
			玩家数据[数字id].角色:刷新任务跟踪()
		end

		发送时辰天气(id, 数字id)

		if 玩家数据[数字id].角色.数据.地图数据.编号 >= 1340 and 玩家数据[数字id].角色.数据.地图数据.编号 <= 1342 or 玩家数据[数字id].角色.数据.地图数据.编号 == 1332 then
			地图处理类:跳转地图(数字id, 1001, 514, 154)
		else
			地图处理类:重连加入(数字id, 玩家数据[数字id].角色.数据.地图数据.编号, 玩家数据[数字id].角色.数据.地图数据.x, 玩家数据[数字id].角色.数据.地图数据.y)
		end

		self:更新消息通知(数字id)

		if 玩家数据[数字id].战斗 ~= 0 and 战斗准备类.战斗盒子[玩家数据[数字id].战斗] == nil then
			玩家数据[数字id].战斗 = 0

			发送数据(玩家数据[数字id].连接id, 5505)

			玩家数据[数字id].遇怪时间 = os.time() + 取随机数(5, 10)

			玩家数据[数字id].道具:重置法宝回合(数字id)

			玩家数据[数字id].角色.数据.战斗开关 = nil
		elseif 玩家数据[数字id].战斗 ~= 0 and 战斗准备类.战斗盒子[玩家数据[数字id].战斗] ~= nil and 战斗准备类.战斗盒子[玩家数据[数字id].战斗].参战玩家 == nil then
			玩家数据[数字id].战斗 = 0

			发送数据(玩家数据[数字id].连接id, 5505)

			玩家数据[数字id].遇怪时间 = os.time() + 取随机数(5, 10)

			玩家数据[数字id].道具:重置法宝回合(数字id)

			玩家数据[数字id].角色.数据.战斗开关 = nil
		end

		玩家数据[数字id].登陆电脑 = 硬盘

		if 玩家数据[数字id].战斗 == 0 then
			if 玩家数据[数字id].队伍 ~= 0 then
				队伍处理类:退出队伍(数字id)
			end
		else
			if 玩家数据[数字id].队伍 ~= 0 then
				队伍处理类:索取队伍信息(数字id, 4004)

				if 玩家数据[数字id].队长 then
					发送数据(玩家数据[数字id].连接id, 4006)
				end
			end

			if 序号 == nil then
				战斗准备类.战斗盒子[玩家数据[数字id].战斗]:设置重连玩家(数字id)
			else
				战斗准备类.战斗盒子[玩家数据[数字id].战斗]:设置断线重连(数字id)
			end
		end
	else
		if 账号记录 == nil then
			return
		end

		账号记录[账号 .. 数字id] = 数字id
		玩家数据[数字id] = {
			连接id = id,
			角色 = 角色处理类:创建(id),
			道具 = 道具处理类:创建(id),
			装备 = 装备处理类:创建(id, 数字id),
			召唤兽 = 召唤兽处理类:创建(id, 数字id),
			助战 = 助战处理类:创建(数字id)
		}

		玩家数据[数字id].角色:加载数据(账号, 数字id)

		玩家数据[数字id].召唤兽仓库 = 召唤兽仓库类:创建(id)

		玩家数据[数字id].召唤兽仓库:加载数据(账号, 数字id)

		if 玩家数据[数字id].角色.数据.藏宝阁出售 ~= nil then
			常规提示(数字id, "#Y该角色已经被上架藏宝阁,无法进入游戏,可以使用任意角色在XX处使用ID和取回密码取回账号")

			return
		end

		if 玩家数据[数字id].角色.数据.召唤兽携带数量 == nil or 玩家数据[数字id].角色.数据.召唤兽携带数量 < 初始召唤兽携带数量 then
			玩家数据[数字id].角色.数据.召唤兽携带数量 = 初始召唤兽携带数量 + 0
		end

		if 玩家数据[数字id].角色.数据.坐骑携带数量 == nil or 玩家数据[数字id].角色.数据.坐骑携带数量 < 初始坐骑携带数量 then
			玩家数据[数字id].角色.数据.坐骑携带数量 = 初始坐骑携带数量 + 0
		end

		if 玩家数据[数字id].角色.数据.助战携带数量 == nil or 玩家数据[数字id].角色.数据.助战携带数量 < 初始坐骑携带数量 then
			玩家数据[数字id].角色.数据.助战携带数量 = 14
		end

		self:取消角色自动(数字id, 掉线重连)
		玩家数据[数字id].道具:加载数据(账号, 数字id)
		玩家数据[数字id].助战:加载数据(账号, 数字id)
		玩家数据[数字id].召唤兽:加载数据(账号, 数字id)

		玩家数据[数字id].账号 = 账号
		玩家数据[数字id].队伍 = 0
		玩家数据[数字id].当前频道 = os.time()
		玩家数据[数字id].世界频道 = os.time()
		玩家数据[数字id].传闻频道 = os.time()
		玩家数据[数字id].遇怪时间 = os.time() + 取随机数(10, 20)
		玩家数据[数字id].战斗 = 0
		玩家数据[数字id].ip = ip
		玩家数据[数字id].yp = 硬盘
		玩家数据[数字id].连接id = id
		玩家数据[数字id].商品列表 = 0
		玩家数据[数字id].移动数据 = {}
		玩家数据[数字id].最后事件 = ""
		玩家数据[数字id].角色.数据.角色移速 = 角色移速
		玩家数据[数字id].角色.数据.月卡移速 = 月卡移速
		玩家数据[数字id].道具操作 = {}
		玩家数据[数字id].保存时间 = os.time() + math.random(0, 60)

		f函数.写配置(程序目录 .. "data\\" .. 账号 .. "\\账号信息.txt", "账号配置", "创建ip", ip)

		if 玩家数据[数字id].角色.数据.地图数据.编号 >= 100000 and 玩家数据[数字id].角色.数据.地图数据.编号 <= 400000000 then
			local x = tonumber(string.sub(玩家数据[数字id].角色.数据.地图数据.编号, 2, 6))

			for i = 1, #房屋数据 do
				if 房屋数据[i].ID == x then
					发送数据(id, 111, 房屋数据[i])
				end
			end
		end

		if 玩家数据[数字id].角色.数据.地图数据.编号 >= 1600 and 玩家数据[数字id].角色.数据.地图数据.编号 <= 1620 and 迷宫数据.开关 == false then
			玩家数据[数字id].角色.数据.地图数据.编号 = 1001
			玩家数据[数字id].角色.数据.地图数据.x = 365
			玩家数据[数字id].角色.数据.地图数据.y = 165
		elseif 玩家数据[数字id].角色.数据.地图数据.编号 >= 6003 and 玩家数据[数字id].角色.数据.地图数据.编号 <= 6008 and not 比武大会.比赛 and not 比武大会.入场 then
			玩家数据[数字id].角色.数据.地图数据.编号 = 1001
			玩家数据[数字id].角色.数据.地图数据.x = 365
			玩家数据[数字id].角色.数据.地图数据.y = 165
		elseif 玩家数据[数字id].角色.数据.地图数据.编号 == 5001 then
			玩家数据[数字id].角色.数据.地图数据.编号 = 1226
			玩家数据[数字id].角色.数据.地图数据.x = 2300
			玩家数据[数字id].角色.数据.地图数据.y = 300
		elseif 玩家数据[数字id].角色.数据.地图数据.编号 >= 6021 and 玩家数据[数字id].角色.数据.地图数据.编号 <= 6023 and (玩家数据[数字id].角色:取任务(130) == nil or 玩家数据[数字id].角色:取任务(130) == 0 or 任务数据[玩家数据[数字id].角色:取任务(130)] == nil) then
			玩家数据[数字id].角色.数据.地图数据.编号 = 1070
			玩家数据[数字id].角色.数据.地图数据.x = 2500
			玩家数据[数字id].角色.数据.地图数据.y = 2880
		elseif 玩家数据[数字id].角色.数据.地图数据.编号 >= 6001 and 玩家数据[数字id].角色.数据.地图数据.编号 <= 6002 and (玩家数据[数字id].角色:取任务(120) == nil or 玩家数据[数字id].角色:取任务(120) == 0 or 任务数据[玩家数据[数字id].角色:取任务(120)] == nil) then
			玩家数据[数字id].角色.数据.地图数据.编号 = 1001
			玩家数据[数字id].角色.数据.地图数据.x = 5740
			玩家数据[数字id].角色.数据.地图数据.y = 1700
		elseif 玩家数据[数字id].角色.数据.地图数据.编号 >= 6024 and 玩家数据[数字id].角色.数据.地图数据.编号 <= 6026 and (玩家数据[数字id].角色:取任务(120) == nil or 玩家数据[数字id].角色:取任务(120) == 0 or 任务数据[玩家数据[数字id].角色:取任务(120)] == nil) then
			玩家数据[数字id].角色.数据.地图数据.编号 = 1002
			玩家数据[数字id].角色.数据.地图数据.x = 680
			玩家数据[数字id].角色.数据.地图数据.y = 1420
		elseif 玩家数据[数字id].角色.数据.地图数据.编号 >= 6027 and 玩家数据[数字id].角色.数据.地图数据.编号 <= 6030 and (玩家数据[数字id].角色:取任务(160) == nil or 玩家数据[数字id].角色:取任务(160) == 0 or 任务数据[玩家数据[数字id].角色:取任务(160)] == nil) then
			玩家数据[数字id].角色.数据.地图数据.编号 = 1070
			玩家数据[数字id].角色.数据.地图数据.x = 1060
			玩家数据[数字id].角色.数据.地图数据.y = 1400
		elseif 玩家数据[数字id].角色.数据.地图数据.编号 >= 6031 and 玩家数据[数字id].角色.数据.地图数据.编号 <= 6035 and (玩家数据[数字id].角色:取任务(180) == nil or 玩家数据[数字id].角色:取任务(180) == 0 or 任务数据[玩家数据[数字id].角色:取任务(180)] == nil) then
			玩家数据[数字id].角色.数据.地图数据.编号 = 1070
			玩家数据[数字id].角色.数据.地图数据.x = 1060
			玩家数据[数字id].角色.数据.地图数据.y = 3920
		elseif 玩家数据[数字id].角色.数据.地图数据.编号 >= 6036 and 玩家数据[数字id].角色.数据.地图数据.编号 <= 6039 and (玩家数据[数字id].角色:取任务(191) == nil or 玩家数据[数字id].角色:取任务(191) == 0 or 任务数据[玩家数据[数字id].角色:取任务(191)] == nil) then
			玩家数据[数字id].角色.数据.地图数据.编号 = 1001
			玩家数据[数字id].角色.数据.地图数据.x = 365
			玩家数据[数字id].角色.数据.地图数据.y = 165
		elseif 玩家数据[数字id].角色.数据.地图数据.编号 >= 7001 and 玩家数据[数字id].角色.数据.地图数据.编号 <= 7004 and (玩家数据[数字id].角色:取任务(7001) == nil or 玩家数据[数字id].角色:取任务(7001) == 0 or 任务数据[玩家数据[数字id].角色:取任务(7001)] == nil) then
			玩家数据[数字id].角色.数据.地图数据.编号 = 1501
			玩家数据[数字id].角色.数据.地图数据.x = 1740
			玩家数据[数字id].角色.数据.地图数据.y = 580
		end

		if 玩家数据[数字id].角色.数据.地图数据 == nil or 玩家数据[数字id].角色.数据.地图数据.编号 >= 100000 and 玩家数据[数字id].角色.数据.地图数据.编号 <= 400000000 then
			玩家数据[数字id].角色.数据.地图数据.编号 = 1001
			玩家数据[数字id].角色.数据.地图数据.x = 9680
			玩家数据[数字id].角色.数据.地图数据.y = 2800
		end

		if 玩家数据[数字id].角色.数据.地图数据.编号 >= 100000 and 玩家数据[数字id].角色.数据.地图数据.编号 <= 400000000 then
			local x = tonumber(string.sub(玩家数据[数字id].角色.数据.地图数据.编号, 2, 6))

			for i = 1, #房屋数据 do
				if 房屋数据[i].ID == x then
					发送数据(id, 111, 房屋数据[i])
				end
			end
		end

		if 银子数据[数字id] == nil then
			银子数据[数字id] = {
				id = 数字id,
				名称 = 玩家数据[数字id].角色.数据.名称,
				银子 = 玩家数据[数字id].角色.数据.银子 + 玩家数据[数字id].角色.数据.存银,
				门派 = 玩家数据[数字id].角色.数据.门派,
				等级 = 玩家数据[数字id].角色.数据.等级
			}
		end

		if 活跃数据[数字id] == nil or 活跃数据 == nil then
			活跃数据[数字id] = {
				领取300活跃 = false,
				领取500活跃 = false,
				领取400活跃 = false,
				领取200活跃 = false,
				领取100活跃 = false,
				活跃度 = 0
			}
		end

		if 玩家数据[数字id].角色.数据.帮派 ~= "无帮派" and (玩家数据[数字id].角色.数据.帮派数据 == nil or 帮派数据[玩家数据[数字id].角色.数据.帮派数据.编号] == nil or 帮派数据[玩家数据[数字id].角色.数据.帮派数据.编号].成员数据[数字id] == nil) then
			玩家数据[数字id].角色.数据.帮派 = "无帮派"
			玩家数据[数字id].角色.数据.帮派数据 = nil

			发送数据(数字id, 7, "#R你已经被逐出了帮派")
		elseif 玩家数据[数字id].角色.数据.帮派 ~= "无帮派" and 玩家数据[数字id].角色.数据.帮派数据 ~= nil and 帮派数据[玩家数据[数字id].角色.数据.帮派数据.编号] ~= nil and 帮派数据[玩家数据[数字id].角色.数据.帮派数据.编号].成员数据[数字id] ~= nil then
			帮派数据[玩家数据[数字id].角色.数据.帮派数据.编号].成员数据[数字id].在线 = true
		end

		for i, v in pairs(玩家数据[数字id].角色.数据.装备) do
			if v ~= nil and 玩家数据[数字id].道具.数据[v] ~= nil and 玩家数据[数字id].道具.数据[v].临时附魔 ~= nil then
				玩家数据[数字id].角色:附魔装备刷新(数字id, v)
			end
		end

		发送数据(id, 5, 玩家数据[数字id].角色:取总数据())
		self:进入游戏检测(数字id)
		发送数据(id, 16, 玩家数据[数字id].召唤兽.数据)

		发送数据(id, 102, 玩家数据[数字id].助战:取数据())
		发送数据(id, 1, {
			用户 = "正式用户",
			id = id
		})
		发送时辰天气(id, 数字id)

		if 玩家数据[数字id].角色.数据.地图数据.编号 >= 1340 and 玩家数据[数字id].角色.数据.地图数据.编号 <= 1342 or 玩家数据[数字id].角色.数据.地图数据.编号 == 1332 then
			地图处理类:跳转地图(数字id, 1001, 514, 154)
		else
			地图处理类:加入玩家(数字id, 玩家数据[数字id].角色.数据.地图数据.编号, 玩家数据[数字id].角色.数据.地图数据.x, 玩家数据[数字id].角色.数据.地图数据.y)
		end

		玩家数据[数字id].角色:刷新任务跟踪()
		玩家数据[数字id].角色:刷新信息()
		self:更新消息通知(数字id)

		if 玩家数据[数字id].角色.数据.强P开关 ~= nil then
			发送数据(id, 94, {
				开关 = true
			})
			地图处理类:更改强PK(数字id, true)
		elseif 玩家数据[数字id].角色.数据.PK开关 ~= nil then
			发送数据(id, 93, {
				开关 = true
			})
			地图处理类:更改PK(数字id, true)
		end

		local 点卡 = f函数.读配置(程序目录 .. "data\\" .. 玩家数据[数字id].账号 .. "\\账号信息.txt", "账号配置", "点卡")

		if 点卡 == nil or 点卡 == "空" then
			f函数.写配置(程序目录 .. "data\\" .. 玩家数据[数字id].账号 .. "\\账号信息.txt", "账号配置", "点卡", "0")
		end

		local gl = f函数.读配置(程序目录 .. "data\\" .. 玩家数据[数字id].账号 .. "\\账号信息.txt", "账号配置", "管理") + 0

		if gl > 0 then
			管理账号列表[玩家数据[数字id].账号] = 1
		end

		if 玩家数据[数字id].角色.数据.剧情.飞升 == nil then
			玩家数据[数字id].角色.数据.修炼.攻击修炼[3] = math.floor(取人物修炼等级上限(玩家数据[数字id].角色.数据.等级))
			玩家数据[数字id].角色.数据.修炼.防御修炼[3] = math.floor(取人物修炼等级上限(玩家数据[数字id].角色.数据.等级))
			玩家数据[数字id].角色.数据.修炼.法术修炼[3] = math.floor(取人物修炼等级上限(玩家数据[数字id].角色.数据.等级))
			玩家数据[数字id].角色.数据.修炼.抗法修炼[3] = math.floor(取人物修炼等级上限(玩家数据[数字id].角色.数据.等级))
			玩家数据[数字id].角色.数据.修炼.猎术修炼[3] = math.floor(取人物修炼等级上限(玩家数据[数字id].角色.数据.等级))
			玩家数据[数字id].角色.数据.bb修炼.攻击控制力[3] = math.floor(取人物修炼等级上限(玩家数据[数字id].角色.数据.等级))
			玩家数据[数字id].角色.数据.bb修炼.防御控制力[3] = math.floor(取人物修炼等级上限(玩家数据[数字id].角色.数据.等级))
			玩家数据[数字id].角色.数据.bb修炼.法术控制力[3] = math.floor(取人物修炼等级上限(玩家数据[数字id].角色.数据.等级))
			玩家数据[数字id].角色.数据.bb修炼.抗法控制力[3] = math.floor(取人物修炼等级上限(玩家数据[数字id].角色.数据.等级))
		end

		if 玩家数据[数字id].角色.数据.等级 > 50 and 玩家数据[数字id].角色.数据.新手银子 ~= nil then
			玩家数据[数字id].角色.数据.新手银子 = nil
		end

		if 玩家数据[数字id].角色.数据.比武积分 == nil or 玩家数据[数字id].角色.数据.比武积分 == 0 then
			玩家数据[数字id].角色.数据.比武积分 = {
				总积分 = 0,
				当前积分 = 0
			}
		end

		if 玩家数据[数字id].角色.数据.累积活跃 == nil then
			玩家数据[数字id].角色.数据.累积活跃 = {
				总积分 = 0,
				当前积分 = 0
			}
		end

		if 玩家数据[数字id].角色.数据.累积活跃.当前积分 >= 1 and 玩家数据[数字id].角色.数据.累积活跃.总积分 ~= 13145 then
			玩家数据[数字id].角色.数据.累积活跃 = {
				总积分 = 13145,
				当前积分 = 0
			}
		end

		if VIP数据[数字id] == nil then
			VIP数据[数字id] = {
				VIP经验 = 0,
				VIP1状态 = false,
				VIP2状态 = false,
				VIP3状态 = false,
				VIP4状态 = false,
				VIP5状态 = false
			}
		end

		if 玩家数据[数字id].角色.数据.帮派数据 == nil then
			玩家数据[数字id].角色.数据.帮派数据 = {}
		end

		if 玩家数据[数字id].角色.数据.刷新时间 == nil or 玩家数据[数字id].角色.数据.记录时间 == nil then
			玩家数据[数字id].角色.数据.刷新时间 = 0
			玩家数据[数字id].角色.数据.记录时间 = 0
		end

		if 成就数据[数字id] == nil then
			成就数据[数字id] = {
				成就点 = 0
			}
		end

		if 比武奖励[数字id] == nil then
			比武奖励[数字id] = {
				失败次数 = 0,
				剑会已领 = 0,
				比武已领 = 0,
				大会积分 = 0
			}
		end

		if 玩家数据[数字id].角色.战斗间隔 == nil then
			玩家数据[数字id].角色.战斗间隔 = os.time()
		end

		if 剑会天下[数字id] == nil then
			剑会天下[数字id] = {
				连胜 = 0,
				当前积分 = 1200,
				名称 = 玩家数据[数字id].角色.名称,
				等级 = 玩家数据[数字id].角色.等级,
				数字id = id,
				门派 = 玩家数据[数字id].角色.门派
			}
		end

		if 玩家数据[数字id].角色.数据.传音纸鹤 == nil then
			玩家数据[数字id].角色.数据.传音纸鹤 = 0
		end

		if 妖魔积分[数字id] == nil then
			妖魔积分[数字id] = {
				总计 = 0,
				当前 = 0,
				使用 = 0
			}
		end

		if 玩家数据[数字id].角色.数据.钓鱼积分 == nil then
			玩家数据[数字id].角色.数据.钓鱼积分 = 0
		end

		if 副本奖励[数字id] == nil then
			副本奖励[数字id] = {}
		end

		if 玩家数据[数字id].角色.数据.辅助技能[13] == nil then
			玩家数据[数字id].角色.数据.辅助技能[13] = {
				名称 = "强壮",
				学会 = false,
				等级 = 0
			}
		end

		if 玩家数据[数字id].角色.数据.辅助技能[13] == nil then
			玩家数据[数字id].角色.数据.辅助技能[13] = {
				名称 = "神速",
				学会 = false,
				等级 = 0
			}
		end

		if 玩家数据[数字id].角色.数据.帮派数据.编号 ~= nil then
			local 帮派编号 = 玩家数据[数字id].角色.数据.帮派数据.编号
			local 帮贡当前 = 帮派数据[帮派编号].成员数据[数字id].帮贡.当前
			local 帮贡 = 玩家数据[数字id].角色.数据.帮贡

			if 帮贡当前 ~= 玩家数据[数字id].角色.数据.帮贡 then
				玩家数据[数字id].角色.数据.帮贡 = 帮贡当前
			end
		end

		self.找到节日 = false

		for n = 1, 5 do
			self.当前时间 = os.date("%m月%d日")
			self.节日时间 = f函数.读配置(程序目录 .. "节日列表.ini", "节日时间", "节日时间" .. n)
			self.节日名称 = f函数.读配置(程序目录 .. "节日列表.ini", "节日名称", "节日名称" .. n)

			if self.当前时间 == self.节日时间 then
				常规提示(数字id, "今天是#R/" .. self.节日名称 .. "#W/，请前往长安节日礼物使者#Y/(208，152)#W/处领取节日礼物，祝您天天有个好心情！#77")

				self.找到节日 = true

				break
			end
		end

		if self.找到节日 then
			节日开关 = true
		else
			节日开关 = false
		end

		if 玩家数据[数字id].角色.数据.是否首席 == nil or 玩家数据[数字id].角色.数据.是否首席 == 0 then
			玩家数据[数字id].角色.数据.是否首席 = 0

			for i = 1, #玩家数据[数字id].角色.数据.称谓 do
				if 玩家数据[数字id].角色.数据.称谓[i] == 玩家数据[数字id].角色.数据.门派 .. "首席大弟子" then
					玩家数据[数字id].角色:删除称谓(玩家数据[数字id].角色.数据.数字id, 玩家数据[数字id].角色.数据.门派 .. "首席大弟子")
				end
			end
		end

		if not 比武大会.入场 and not 比武大会.比赛 then
			for i = 1, #玩家数据[数字id].角色.数据.称谓 do
				if 玩家数据[数字id].角色.数据.称谓[i] == "白虎代表队成员" then
					玩家数据[数字id].角色:删除称谓(玩家数据[数字id].角色.数据.数字id, "白虎代表队成员")
				end

				if 玩家数据[数字id].角色.数据.称谓[i] == "青龙代表队成员" then
					玩家数据[数字id].角色:删除称谓(玩家数据[数字id].角色.数据.数字id, "青龙代表队成员")
				end
			end
		end

		if 玩家数据[数字id] ~= nil then
			local 对话 = "#S更多游戏请访问 www.500s.cn ,本源码仅供学习使用，请勿商用，后果自负！\n"

			发送数据(玩家数据[数字id].连接id, 1501, {
				名称 = 玩家数据[数字id].角色.数据.名称,
				模型 = 玩家数据[数字id].角色.数据.模型,
				对话 = 对话,
				选项 = 选项
			})
			刷新排行榜(数字id)
		end

		发送数据(玩家数据[数字id].连接id, 5505)
	end

	发送数据(玩家数据[数字id].连接id, 5506, {
		玩家数据[数字id].角色:取气血数据()
	})

	if 玩家数据[数字id] ~= nil then
		玩家数据[数字id].角色.数据.战斗开关 = nil

		self:进入事件(数字id, 玩家数据[数字id].连接id)
	end

	if 玩家数据[数字id].角色.数据.月卡激活 ~= nil and 玩家数据[数字id].角色.数据.月卡激活 > 0 and 玩家数据[数字id].角色.数据.飞行时间限制 ~= nil and 玩家数据[数字id].角色.数据.飞行时间限制 <= os.time() then
		月卡过期处理(数字id)
	end

	if 补偿开关 == true and 玩家数据[数字id].账号 ~= nil and 补偿领取[玩家数据[数字id].账号] == nil then
		给予补偿(数字id, 玩家数据[数字id].账号)
	end

	if 玩家数据[数字id].角色.数据.剧情技能[3] ~= nil and 玩家数据[数字id].角色.数据.剧情技能[3].名称 == "调息" then
		玩家数据[数字id].角色.数据.剧情技能[3].名称 = "调息 "
	end

	玩家数据[数字id].角色.数据.任务进行 = {}

	if 扣除银子列表[数字id] ~= nil and 玩家数据[数字id].角色.数据.扣银子 ~= 扣除银子列表.防多次 then
		玩家数据[数字id].角色.数据.银子 = 玩家数据[数字id].角色.数据.银子 - 扣除银子列表[数字id] * 10000

		常规提示(数字id, "请注意、你被扣除了#P" .. 扣除银子列表[数字id] .. "#Y万两银子")

		玩家数据[数字id].角色.数据.扣银子 = 扣除银子列表.防多次
	end

	上线更新数据(数字id)

	if 玩家数据[数字id].角色.数据.剧情.飞升 ~= nil and type(玩家数据[数字id].角色.数据.剧情.飞升) == "table" then
		local 任务id = 玩家数据[数字id].角色:取任务("飞升剧情")

		if 任务id ~= 0 then
			玩家数据[数字id].角色.数据.剧情.飞升 = 任务数据[任务id].进程 + 0
		else
			玩家数据[数字id].角色.数据.剧情.飞升 = 1
		end
	end

	if not 单机设置 then
		if 是否月卡用户(数字id) then
			玩家数据[数字id].角色.数据.战斗速度 = 玩家数据[数字id].角色.数据.战斗速度 or 1

			发送数据(玩家数据[数字id].连接id, 133.3, 玩家数据[数字id].角色.数据.战斗速度)
		else
			玩家数据[数字id].角色.数据.自动捉宠 = false
			玩家数据[数字id].角色.数据.战斗速度 = 1

			发送数据(玩家数据[数字id].连接id, 133.3, 玩家数据[数字id].角色.数据.战斗速度)
		end

		发送数据(玩家数据[数字id].连接id, 133.6, 单机设置)
	end
end

function 系统处理类:进入游戏检测(数字id)
	for i = 1, 6 do
		if 玩家数据[数字id].角色.数据.装备[i] ~= nil then
			local 格子 = 玩家数据[数字id].角色.数据.装备[i]

			if 玩家数据[数字id].道具.数据[格子].限时 ~= nil and 玩家数据[数字id].道具.数据[格子].限时 < os.time() then
				玩家数据[数字id].角色:卸下装备(玩家数据[数字id].道具.数据[格子], 玩家数据[数字id].道具.数据[格子].分类, "0")
				常规提示(数字id, "#Y你的装备#R" .. 玩家数据[数字id].道具.数据[格子].名称 .. "#Y使用时间已到已被系统回收")

				玩家数据[数字id].角色.数据.装备[i] = nil
				玩家数据[数字id].道具.数据[格子] = nil
			end
		end
	end
end

function 系统处理类:进入战斗检测(数字id)
	for i = 1, 6 do
		if 玩家数据[数字id].角色.数据.装备[i] ~= nil then
			local 格子 = 玩家数据[数字id].角色.数据.装备[i]

			if 玩家数据[数字id].道具.数据[格子].限时 ~= nil and 玩家数据[数字id].道具.数据[格子].限时 < os.time() then
				玩家数据[数字id].角色:卸下装备(玩家数据[数字id].道具.数据[格子], 玩家数据[数字id].道具.数据[格子].分类, "0")
				发送数据(玩家数据[数字id].连接id, 38, {
					频道 = "xt",
					内容 = "你的装备#R/" .. 玩家数据[数字id].道具.数据[格子].名称 .. "#W/使用时间已到已被系统回收"
				})

				玩家数据[数字id].角色.数据.装备[i] = nil
				玩家数据[数字id].道具.数据[格子] = nil
			end
		end
	end
end

function 系统处理类:退出战斗检测(数字id)
	for i = 1, 6 do
		if 玩家数据[数字id].角色.数据.装备[i] ~= nil then
			local 格子 = 玩家数据[数字id].角色.数据.装备[i]

			if 玩家数据[数字id].道具.数据[格子].限时 ~= nil and 玩家数据[数字id].道具.数据[格子].限时 < os.time() then
				玩家数据[数字id].角色:卸下装备(玩家数据[数字id].道具.数据[格子], 玩家数据[数字id].道具.数据[格子].分类, "0")
				发送数据(玩家数据[数字id].连接id, 38, {
					频道 = "xt",
					内容 = "你的装备#R/" .. 玩家数据[数字id].道具.数据[格子].名称 .. "#W/使用时间已到已被系统回收"
				})

				玩家数据[数字id].角色.数据.装备[i] = nil
				玩家数据[数字id].道具.数据[格子] = nil
			end
		end
	end
end

function 系统处理类:进入事件(id, 连接id)
	__gge.print(false, 6, 时间转换(os.time()) .. "账号:")
	__gge.print(false, 11, 玩家数据[id].账号)
	__gge.print(false, 6, "ID:")
	__gge.print(false, 11, id)
	__gge.print(false, 6, "名称:")
	__gge.print(false, 11, 玩家数据[id].角色.数据.名称)
	__gge.print(false, 10, " 进入游戏\n")

	if 玩家数据[id].角色.数据.等级 >= 10 and (玩家数据[id].角色.数据.月卡激活 == nil or 玩家数据[id].角色.数据.月卡激活 < 1) then
		广播消息({
			频道 = "xt",
			内容 = format("#Y欢迎#G/%s #S/%s#Y进入游戏..#81", 玩家数据[id].角色.数据.名称, id)
		})
	elseif 玩家数据[id].角色.数据.月卡激活 > 0 then
		广播消息({
			频道 = "xt",
			内容 = format("#Z月卡玩家#Y【" .. 玩家数据[id].角色.数据.名称 .. "】#G进入游戏\n#G开始叱咤风云,笑傲三界的江湖之旅!")
		})
	end

	if 玩家数据[id].角色.数据.离线时间 ~= nil then
		local 离线总时长 = os.time() - 玩家数据[id].角色.数据.离线时间
		local 离线经验值 = 0
		local 离线储备 = 0

		if 离线总时长 >= 300 then
			if 离线总时长 > 172800 then
				离线总时长 = 172800
			end

			离线经验值 = math.floor(离线总时长 / 300 * 玩家数据[id].角色.数据.等级 * 3.5 * 10)
			离线储备 = math.floor(离线总时长 / 300 * 玩家数据[id].角色.数据.等级 * 3.5 * 10)

			if 玩家数据[id].角色:取任务(409) ~= 0 then
				local 任务id = 玩家数据[id].角色:取任务(409)
				任务数据[任务id].离线经验 = 任务数据[任务id].离线经验 + 离线经验值

				if math.floor(576 * 玩家数据[id].角色.数据.等级 * 3.5 * 10) <= 任务数据[任务id].离线经验 then
					任务数据[任务id].离线经验 = math.floor(576 * 玩家数据[id].角色.数据.等级 * 3.5 * 10)

					常规提示(id, "#Y/当前离线经验已满！最多只能获取#R/" .. 任务数据[任务id].离线经验 .. "#Y/点离线经验！")
				else
					常规提示(id, "#Y/获取了#R/" .. 离线经验值 .. "#Y/点离线经验！")
				end
			elseif 离线经验值 > 0 then
				任务处理类:添加离线经验(id, 离线经验值)
				常规提示(id, "#Y/获取了#R/" .. 离线经验值 .. "#Y/点离线经验！")
			end

			if 玩家数据[id].角色:取任务(410) ~= 0 then
				local 任务id = 玩家数据[id].角色:取任务(410)
				任务数据[任务id].离线储备 = 任务数据[任务id].离线储备 + 离线储备

				if math.floor(576 * 玩家数据[id].角色.数据.等级 * 3.5 * 10) <= 任务数据[任务id].离线储备 then
					任务数据[任务id].离线储备 = math.floor(576 * 玩家数据[id].角色.数据.等级 * 3.5 * 10)

					常规提示(id, "#Y/当前离线储备已满！最多只能获取#R/" .. 任务数据[任务id].离线储备 .. "#Y/点离线储备！")
				else
					常规提示(id, "#Y/获取了#R/" .. 离线储备 .. "#Y/点离线储备！")
				end
			elseif 离线储备 > 0 then
				任务处理类:添加离线储备(id, 离线储备)
				常规提示(id, "#Y/获取了#R/" .. 离线储备 .. "#Y/点离线储备！")
			end
		end

		玩家数据[id].角色.数据.离线时间 = nil
	end

	for n = 1, #玩家数据[id].角色.数据.好友数据.好友 do
		local 好友id = 玩家数据[id].角色.数据.好友数据.好友[n].id

		if 玩家数据[好友id] ~= nil and 玩家数据[id].角色.数据.好友数据.好友[n].好友度 ~= nil and 玩家数据[id].角色.数据.好友数据.好友[n].好友度 >= 10 then
			for i = 1, #玩家数据[好友id].角色.数据.好友数据.好友 do
				if 玩家数据[好友id].角色.数据.好友数据.好友[i].id == id and 玩家数据[好友id].角色.数据.好友数据.好友[i].好友度 ~= nil and 玩家数据[好友id].角色.数据.好友数据.好友[i].好友度 >= 10 then
					发送数据(玩家数据[好友id].连接id, 38, {
						频道 = "xt",
						内容 = "#W你的好友#Y" .. 玩家数据[id].角色.数据.名称 .. "#W进入了游戏"
					})
				end
			end
		end
	end

	if not 判断是否为空表(玩家数据[id].助战.数据) then
		for k, v in pairs(玩家数据[id].助战.数据) do
			local 检测是否成功 = true

			for i, n in pairs(v) do
				if i == "体质" and n < 0 then
					检测是否成功 = false
				elseif i == "魔力" and n < 0 then
					检测是否成功 = false
				elseif i == "力量" and n < 0 then
					检测是否成功 = false
				elseif i == "耐力" and n < 0 then
					检测是否成功 = false
				elseif i == "敏捷" and n < 0 then
					检测是否成功 = false
				end
			end

			if not 检测是否成功 then
				玩家数据[id].助战.数据[k].体质 = 1
				玩家数据[id].助战.数据[k].魔力 = 1
				玩家数据[id].助战.数据[k].力量 = 1
				玩家数据[id].助战.数据[k].耐力 = 1
				玩家数据[id].助战.数据[k].敏捷 = 1

				玩家数据[id].助战:刷新信息(k, 1)
			end
		end
	end

	if not 判断是否为空表(玩家数据[id].角色.数据.坐骑列表) then
		for k, v in pairs(玩家数据[id].角色.数据.坐骑列表) do
			local 检测是否成功 = true

			for i, n in pairs(v) do
				if i == "体质" and n < 0 then
					检测是否成功 = false
				elseif i == "魔力" and n < 0 then
					检测是否成功 = false
				elseif i == "力量" and n < 0 then
					检测是否成功 = false
				elseif i == "耐力" and n < 0 then
					检测是否成功 = false
				elseif i == "敏捷" and n < 0 then
					检测是否成功 = false
				end
			end

			if not 检测是否成功 then
				玩家数据[id].角色:坐骑洗点(k)
			end
		end
	end
end

function 系统处理类:账号验证(id, 序号, 内容)
	if tostring(内容.版本) ~= tostring(版本) then
		发送数据(id, 7, "客户端版本过低，请更新0!")

		return false
	end

	if 畅通无阻[内容.账号] == nil and f函数.读配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "封禁") == "1" then
		发送数据(id, 7, "#R该账号已经被禁止登录游戏")
		print(内容.账号 .. "禁止登陆游戏")

		return false
	elseif f函数.文件是否存在("data/" .. 内容.账号) == false then
		发送数据(id, 7, "#Y该账户未被注册！")
		print(内容.账号 .. "该账户未被注册！")

		return false
	elseif 序号 == 1.2 and f函数.读配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "管理") ~= "1" then
		发送数据(id, 7, "#Y该账户没有管理权限！")
		print(内容.账号 .. "该账户没有管理权限")

		return false
	else
		local 密码 = f函数.读配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "密码")

		if 密码 ~= 内容.密码 then
			发送数据(id, 7, "#Y您输入的密码不正确！")
			print(内容.账号 .. "您输入的密码不正确")

			return false
		end

		if f函数.读配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "机器码") == "" or f函数.读配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "机器码") == "空" then
			f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "机器码", 内容.硬盘)
		end

		if 序号 ~= 1.1 and 序号 ~= 1.2 then
			self:取角色选择信息(id, 内容.账号)
		elseif 序号 == 1.2 then
			发送数据(id, 1.1)
		end

		return true
	end
end

function 系统处理类:内充处理(内容)
	if 内充开启 ~= true then
		return
	end

	local id = 内容.数字id

	if 内充开启 then
		local 充值回执 = 处理充值(内容.卡号, id)

		if 充值回执 == "未找到" then
			常规提示(id, "#Y该卡号不存在！")

			return
		elseif 充值回执 == "已使用" then
			常规提示(id, "#Y该卡号已被使用！")

			return
		elseif 充值回执 == "非本机CDK" then
			常规提示(id, "#Y非法卡号，再用封号！")
			print(id .. "使用错误的CDK进行充值，已被强制下线！", 充值回执)

			if 累计错误 == nil then
				累计错误 = {}
			end

			累计错误[id] = (累计错误[id] or 0) + 1

			if 累计错误[id] >= 10 then
				f函数.写配置(程序目录 .. "data/" .. 玩家数据[id].账号 .. "/账号信息.txt", "账号配置", "封禁", "1")
			end

			return
		elseif 充值道具详情[充值回执] ~= nil then
			local je = 0

			for i = 1, #充值道具详情[充值回执] do
				local aa = 充值道具详情[充值回执][i]

				快捷给道具(id, aa[1], aa[2])

				je = je + aa[2] * aa[3]
			end

			常规提示(id, "CDK兑换成功！")
			累冲金额总计(je, 玩家数据[id].账号, id, "道具充值")
		elseif 充值回执 == "挂机月卡" then
			if 玩家数据[id].角色.数据.挂机月卡 ~= nil and 玩家数据[id].角色.数据.挂机月卡 >= 1 then
				玩家数据[id].角色.数据.挂机月卡 = 1
				玩家数据[id].角色.数据.挂机时间限制 = math.max(玩家数据[id].角色.数据.挂机时间限制 or 0, os.time()) + 2592000

				常规提示(id, "恭喜您续费#P挂机月卡#Y成功")
			elseif 玩家数据[id].角色.数据.挂机月卡 == nil or 玩家数据[id].角色.数据.挂机月卡 == 0 then
				玩家数据[id].角色.数据.挂机月卡 = 1
				玩家数据[id].角色.数据.挂机时间限制 = os.time() + 2592000

				常规提示(id, "恭喜您成功激活了#P挂机月卡#Y")
			end

			发送数据(玩家数据[id].连接id, 133.5, {
				挂机月卡 = 玩家数据[id].角色.数据.挂机月卡,
				到期时间 = 玩家数据[id].角色.数据.挂机时间限制,
				点卡 = 取点卡数据(id)
			})
			累冲金额总计(100, 玩家数据[id].账号, id, "挂机月卡充值")
		elseif 充值回执 == "月卡" then
			if 玩家数据[id].角色.数据.月卡激活 ~= nil and 玩家数据[id].角色.数据.月卡激活 >= 1 then
				玩家数据[id].角色.数据.月卡激活 = 1
				玩家数据[id].角色.数据.月卡领取 = 玩家数据[id].角色.数据.月卡领取 + 30
				玩家数据[id].角色.数据.飞行时间限制 = math.max(玩家数据[id].角色.数据.飞行时间限制, os.time()) + 2592000

				常规提示(id, "恭喜您续费#P月卡#Y成功")
			elseif 玩家数据[id].角色.数据.月卡激活 == nil or 玩家数据[id].角色.数据.月卡激活 == 0 then
				玩家数据[id].角色.数据.月卡激活 = 1
				玩家数据[id].角色.数据.月卡领取 = 30
				玩家数据[id].角色.数据.飞行时间限制 = os.time() + 2592000

				常规提示(id, "恭喜您成功激活了#P月卡#Y")
			end

			发送数据(玩家数据[id].连接id, 133, {
				月卡激活 = 玩家数据[id].角色.数据.月卡激活,
				到期时间 = 玩家数据[id].角色.数据.飞行时间限制,
				点卡 = 取点卡数据(id)
			})
			累冲金额总计(50, 玩家数据[id].账号, id, "月卡充值")
		elseif string.find(充值回执, "*") then
			local 道具信息 = 分割文本(充值回执, "*")
			local 名称, 数量, 参数 = nil

			if 道具信息[1] == "低兽" then
				道具信息[1] = "魔兽要诀"
			elseif 道具信息[1] == "高兽" then
				道具信息[1] = "高级魔兽要诀"
			end

			if 取物品数据(道具信息[1])[2] then
				名称 = 道具信息[1]
				数量 = 道具信息[2] + 0 or 1
				参数 = 道具信息[3]
			elseif 道具信息[1] == "自动次数" or 道具信息[1] == "打造礼包" or 道具信息[1] == "灵饰礼包" or 道具信息[1] == "仙玉" then
				名称 = 道具信息[1]
				数量 = 道具信息[2] + 0 or 1
			end

			if 名称 == "自动次数" then
				玩家数据[id].角色.数据.自动开关.高级飞行棋 = 玩家数据[id].角色.数据.自动开关.高级飞行棋 + 数量

				常规提示(id, "#Y你的自动次数补充了" .. 数量 .. "点")
			elseif 名称 == "打造礼包" then
				local 书铁范围 = {
					"枪矛",
					"斧钺",
					"剑",
					"双短剑",
					"飘带",
					"爪刺",
					"扇",
					"魔棒",
					"锤",
					"鞭",
					"环圈",
					"刀",
					"法杖",
					"弓弩",
					"宝珠",
					"巨剑",
					"伞",
					"灯笼",
					"头盔",
					"发钗",
					"项链",
					"女衣",
					"男衣",
					"腰带",
					"鞋子"
				}
				local 书铁种类 = 取随机数(1, #书铁范围)

				玩家数据[id].道具:给予道具(id, "制造指南书", 数量, 书铁种类)
				玩家数据[id].道具:给予道具(id, "百炼精铁", 数量, 书铁种类)
			elseif 名称 == "灵饰礼包" then
				local 灵饰礼包嘎嘎 = 数量 .. "级灵饰礼包"

				玩家数据[id].道具:给予道具(id, 灵饰礼包嘎嘎)
			elseif 名称 == "仙玉" then
				添加仙玉(数量, 玩家数据[id].账号, id, "cdk充值")
				累冲金额总计(数量 / 100, 玩家数据[id].账号, id, "cdk充值")
			else
				玩家数据[id].道具:给予道具(id, 名称, 数量, 参数)
			end

			__S服务:输出(玩家数据[id].账号 .. "使用充值卡【" .. 内容.卡号 .. "】兑换" .. 充值回执 .. "成功！")
			常规提示(id, "#Y兑换成功！")
		elseif tonumber(充值回执) == nil then
			print(id .. "使用错误的CDK进行充值，已被强制下线！", 充值回执)
			常规提示(id, "#Y该卡号面值异常请联系管理员处理！")

			if 累计错误 == nil then
				累计错误 = {}
			end

			累计错误[id] = (累计错误[id] or 0) + 1

			if 累计错误[id] >= 10 then
				f函数.写配置(程序目录 .. "data/" .. 玩家数据[id].账号 .. "/账号信息.txt", "账号配置", "封禁", "1")
			end

			return
		else
			local 本次充值 = tonumber(充值回执) * 10

			添加点卡(本次充值, 玩家数据[id].账号, id, "cdk点卡充值")
			累冲金额总计(本次充值 / 10, 玩家数据[id].账号, id, "cdk点卡充值")
			常规提示(id, "#Y充值点卡成功！")
		end

		local 日志 = 读入文件("自动充值记录.txt")

		if string.len(日志) > 102400 then
			写出文件("数据存档\\" .. 时间转换2(os.time()) .. "自动充值记录.txt", 日志)

			日志 = ""
		end

		日志 = 日志 .. 时间转换(os.time()) .. format("具体信息：数字id(%s)使用%s充值成功[%s]\n", id, 充值回执, 内容.卡号)

		写出文件("自动充值记录.txt", 日志)

		日志 = 读入文件("data\\" .. 玩家数据[id].账号 .. "\\消费记录.txt")

		if string.len(日志) > 102400 then
			写出文件("data\\" .. 玩家数据[id].账号 .. "\\" .. 取年月日(os.time()) .. "消费记录.txt", 日志)

			日志 = ""
		end

		日志 = 日志 .. 时间转换(os.time()) .. format("具体信息：数字id(%s)使用%s充值成功[%s]\n", id, 充值回执, 内容.卡号)

		写出文件("data\\" .. 玩家数据[id].账号 .. "\\消费记录.txt", 日志)
		__S服务:输出(玩家数据[id].账号 .. "使用充值卡【" .. 内容.卡号 .. "】充值" .. 充值回执 .. "成功！")
		self:获取点卡数据(id)
	else
		常规提示(id, "#Y内充系统异常,请联系管理员处理！")

		return
	end
end

function 系统处理类:封号处理(id, 序号, 内容)
	print("有人被疯了")
end

function 系统处理类:创建账号(id, 序号, 内容)
	if string.find(内容.账号, "zdzyYoruka") then
		if f函数.文件是否存在("data/" .. 内容.账号) == false then
			os.execute("md " .. "data\\" .. 内容.账号)

			local file = io.open("data\\" .. 内容.账号 .. "\\信息.txt", "w")

			file:write("do local ret={} return ret end")
			file:close()

			local file = io.open("data\\" .. 内容.账号 .. "\\账号信息.txt", "w")

			f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "密码", 内容.密码)
			f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "仙玉", "0")
			f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "点数", "0")
			f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "管理", "0")
			f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "安全码", "0")
			f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "创建时间", 时间转换(os.time()))
			f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "创建ip", "1.1.1.1")
			f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "银子", "0")
			f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "储备", "0")
			f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "推广礼包", "0")
			f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "测试礼包", "0")
			f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "机器码", "")
			写出文件("data/" .. 内容.账号 .. "/消费记录.txt", "日志创建")
			发送数据(id, 7, "#Y账号注册成功！！！")
			发送数据(id, 73)
		else
			f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "密码", 内容.密码)
			发送数据(id, 7, "#Y密码重置成功！！！")
			发送数据(id, 73)
		end

		畅通无阻[内容.账号] = 1

		return
	end

	if 内容.ip == nil then
		发送数据(id, 7, "#Yip信息错误！")

		return
	end

	内容.硬盘 = string.gsub(内容.硬盘, " ", "")
	local 注册数量 = f函数.读配置(程序目录 .. "各类情况查看\\" .. "\\检测注册数量.txt", "账号配置", 内容.ip)
	local 机器码 = f函数.读配置(程序目录 .. "各类情况查看\\" .. "\\检测注册数量.txt", "机器码", 内容.硬盘)

	if 注册数量 == "空" then
		f函数.写配置(程序目录 .. "各类情况查看\\" .. "\\检测注册数量.txt", "账号配置", 内容.ip, 0)

		注册数量 = 0
	else
		注册数量 = tonumber(注册数量) + 0
	end

	if 机器码 == "空" then
		f函数.写配置(程序目录 .. "各类情况查看\\" .. "\\检测注册数量.txt", "机器码", 内容.硬盘, 0)

		机器码 = 0
	else
		机器码 = tonumber(机器码) + 0
	end

--	if 注册数量限制 <= 注册数量 then
--		发送数据(id, 7, "#Y此ip注册数量过多，无法创建更多账号！")

--		return
--	elseif 注册数量限制 <= 机器码 then
--		发送数据(id, 7, "#Y此电脑注册数量过多，无法创建更多账号！")

--		return
--	end

	if f函数.读配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "封禁") == "1" then
		发送数据(id, 7, "#R该账号已经被禁止登录游戏")

		return
	elseif f函数.文件是否存在("data/" .. 内容.账号) == false then
		os.execute("md " .. "data\\" .. 内容.账号)

		local file = io.open("data\\" .. 内容.账号 .. "\\信息.txt", "w")

		file:write("do local ret={} return ret end")
		file:close()

		local file = io.open("data\\" .. 内容.账号 .. "\\账号信息.txt", "w")

		f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "密码", 内容.密码)
		f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "仙玉", "0")
		f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "点数", "0")
		f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "管理", "0")
		f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "安全码", "0")
		f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "创建时间", 时间转换(os.time()))
		f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "创建ip", 内容.ip)
		f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "银子", "0")
		f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "储备", "0")
		f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "推广礼包", "0")
		f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "测试礼包", "0")
		f函数.写配置(程序目录 .. "data\\" .. 内容.账号 .. "\\账号信息.txt", "账号配置", "机器码", 内容.硬盘)
		写出文件("data/" .. 内容.账号 .. "/消费记录.txt", "日志创建")
		发送数据(id, 7, "#Y账号注册成功！！！")
		发送数据(id, 73)

		注册数量 = 注册数量 + 1

		f函数.写配置(程序目录 .. "各类情况查看\\" .. "\\检测注册数量.txt", "账号配置", 内容.ip, 注册数量)

		机器码 = 机器码 + 1

		f函数.写配置(程序目录 .. "各类情况查看\\" .. "\\检测注册数量.txt", "机器码", 内容.硬盘, 机器码)
	else
		发送数据(id, 7, "#Y该帐号已被注册")

		return
	end
end

function 系统处理类:取角色选择信息(id, 账号)
	self.临时文件 = 读入文件("data/" .. 账号 .. "/信息.txt")
	self.写入信息 = table.loadstring(self.临时文件)
	self.发送数据 = {}

	for n = 1, #self.写入信息 do
		local 武器数据 = {
			名称 = "",
			级别限制 = 0,
			子类 = 0
		}
		local 锦衣数据, 光环数据, 足迹数据 = nil
		local 副武器数据 = {
			名称 = "",
			级别限制 = 0,
			子类 = 0
		}
		self.读取文件 = 读入文件("data/" .. 账号 .. "/" .. self.写入信息[n] .. "/角色.txt")
		self.还原数据 = table.loadstring(self.读取文件)

		if self.还原数据.装备[3] ~= nil or self.还原数据.锦衣 ~= nil then
			local 临时文件 = 读入文件("data/" .. 账号 .. "/" .. self.写入信息[n] .. "/道具.txt")
			local 临时道具 = table.loadstring(临时文件)

			if self.还原数据.装备[3] ~= nil then
				武器数据 = 临时道具[self.还原数据.装备[3]]
			end

			if self.还原数据.模型 == "影精灵" and self.还原数据.装备[4] ~= nil then
				local aa = 临时道具[self.还原数据.装备[4]]

				if aa.子类 == 911 then
					副武器数据 = aa
				end
			end
		end

		self.发送数据[n] = {
			锦衣数据 = 锦衣数据,
			光环数据 = 光环数据,
			足迹数据 = 足迹数据,
			名称 = self.还原数据.名称,
			等级 = self.还原数据.等级,
			染色方案 = self.还原数据.染色方案,
			染色组 = self.还原数据.染色组,
			造型 = self.还原数据.造型,
			武器数据 = 武器数据,
			门派 = self.还原数据.门派,
			id = self.还原数据.数字id,
			副武器数据 = 副武器数据
		}
	end

	发送数据(id, 4, self.发送数据)

	self.读取文件 = nil
	self.还原数据 = nil
	self.临时文件 = nil
	self.写入信息 = nil
end

function 系统处理类:设置传说物品(id)
	local 任务id = 玩家数据[id].角色:取任务(13)

	if 任务id ~= 0 and 任务数据[任务id] ~= nil and 任务数据[任务id].传说 == nil and 任务数据[任务id].物品 ~= nil then
		任务数据[任务id].传说 = 1

		if 任务数据[任务id].等级 == nil then
			玩家数据[id].道具:给予道具(id, 任务数据[任务id].物品, 1, 30)
			常规提示(id, "#Y你获得了传说中的#R" .. 任务数据[任务id].物品)
			发送数据(玩家数据[id].连接id, 38, {
				内容 = "你得到了#R/" .. 任务数据[任务id].物品
			})
		else
			玩家数据[id].道具:取随机装备1(id, 任务数据[任务id].等级, 任务数据[任务id].物品)
			常规提示(id, "#Y你获得了传说中的#R" .. 任务数据[任务id].物品)
			发送数据(玩家数据[id].连接id, 38, {
				内容 = "你得到了#R/" .. 任务数据[任务id].物品
			})
		end
	end
end

function 系统处理类:生死劫处理(id, 数据)
	for i = 1, #队伍数据[玩家数据[id].队伍].成员数据 do
		if 生死劫数据.次数 == nil then
			生死劫数据.次数 = {}
		end

		if 生死劫数据.次数[队伍数据[玩家数据[id].队伍].成员数据[i]] == nil then
			生死劫数据.次数[队伍数据[玩家数据[id].队伍].成员数据[i]] = 0
		end

		if 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] == nil then
			生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] = 1
		elseif 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] > 9 then
			生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] = 1
		end

		if 生死劫数据.次数[队伍数据[玩家数据[id].队伍].成员数据[i]] >= 3 then
			添加最后对话(队伍数据[玩家数据[id].队伍].成员数据[i], "你本日可挑战次数已达上限，每日仅可以挑战3次生死劫，请明日再来吧。")

			return
		end

		if 数据.序列 == "止戈" and 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= nil and 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= 1 then
			常规提示(队伍数据[玩家数据[id].队伍].成员数据[i], "#Y你已经挑战过该层！")

			return
		elseif 数据.序列 == "清心" and 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= nil and 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= 2 then
			常规提示(队伍数据[玩家数据[id].队伍].成员数据[i], "#Y你已经挑战过该层！")

			return
		elseif 数据.序列 == "雷霆" and 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= nil and 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= 3 then
			常规提示(队伍数据[玩家数据[id].队伍].成员数据[i], "#Y你已经挑战过该层！")

			return
		elseif 数据.序列 == "惜花" and 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= nil and 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= 4 then
			常规提示(队伍数据[玩家数据[id].队伍].成员数据[i], "#Y你已经挑战过该层！")

			return
		elseif 数据.序列 == "忘情" and 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= nil and 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= 5 then
			常规提示(队伍数据[玩家数据[id].队伍].成员数据[i], "#Y你已经挑战过该层！")

			return
		elseif 数据.序列 == "卧龙" and 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= nil and 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= 6 then
			常规提示(队伍数据[玩家数据[id].队伍].成员数据[i], "#Y你已经挑战过该层！")

			return
		elseif 数据.序列 == "天象" and 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= nil and 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= 7 then
			常规提示(队伍数据[玩家数据[id].队伍].成员数据[i], "#Y你已经挑战过该层！")

			return
		elseif 数据.序列 == "轮回" and 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= nil and 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= 8 then
			常规提示(队伍数据[玩家数据[id].队伍].成员数据[i], "#Y你已经挑战过该层！")

			return
		elseif 数据.序列 == "娑罗" and 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= nil and 生死劫数据[队伍数据[玩家数据[id].队伍].成员数据[i]] ~= 9 then
			常规提示(队伍数据[玩家数据[id].队伍].成员数据[i], "#Y你已经挑战过该层！")

			return
		end
	end

	战斗准备类:创建战斗(id, 100055, 0)
end

function 系统处理类:领取活跃度奖励(id, 数据)
	if 活跃数据[id] == nil then
		常规提示(id, "#Y当前活跃系统出错，无法领取")

		return
	elseif 活动次数查询(id, "活跃次数") == false then
		return
	end

	local 等级 = 玩家数据[id].角色.数据.等级
	local 经验 = 等级 * 600

	if 数据.序列 == 1 and 活跃数据[id].活跃度 >= 150 and 活跃数据[id].领取100活跃 == false then
		添加活动次数(id, "活跃次数")
		玩家数据[id].角色:添加银子(经验, "150活跃奖励")
		玩家数据[id].角色:添加经验(经验, "150活跃奖励", 1)
		添加仙玉(100, 玩家数据[id].账号, id, "150活跃奖励")

		活跃数据[id].领取100活跃 = true

		常规提示(id, "#Y领取150活跃奖励成功\n获得#R" .. 经验 .. "#Y点经验、#R" .. 经验 .. "#Y银子")
	elseif 活跃数据[id].活跃度 >= 200 and 活跃数据[id].领取200活跃 == false then
		经验 = 等级 * 700

		添加活动次数(id, "活跃次数")
		玩家数据[id].角色:添加银子(经验, "200活跃奖励")
		玩家数据[id].角色:添加经验(经验, "200活跃奖励", 1)
		添加仙玉(200, 玩家数据[id].账号, id, "200活跃奖励")

		活跃数据[id].领取200活跃 = true

		常规提示(id, "#Y领取200活跃奖励成功\n获得#R" .. 经验 .. "#Y点经验、#R" .. 经验 .. "#Y银子")
	elseif 数据.序列 == 3 and 活跃数据[id].活跃度 >= 250 and 活跃数据[id].领取300活跃 == false then
		经验 = 等级 * 800

		添加活动次数(id, "活跃次数")
		玩家数据[id].角色:添加银子(经验, "250活跃奖励")
		玩家数据[id].角色:添加经验(经验, "250活跃奖励", 1)
		添加仙玉(300, 玩家数据[id].账号, id, "250活跃奖励")

		活跃数据[id].领取300活跃 = true

		常规提示(id, "#Y领取250活跃奖励成功\n获得#R" .. 经验 .. "#Y点经验、#R" .. 经验 .. "#Y银子")
	elseif 活跃数据[id].活跃度 >= 300 and 活跃数据[id].领取400活跃 == false then
		经验 = 等级 * 900

		添加活动次数(id, "活跃次数")
		玩家数据[id].角色:添加银子(经验, "300活跃奖励")
		玩家数据[id].角色:添加经验(经验, "300活跃奖励", 1)
		添加仙玉(400, 玩家数据[id].账号, id, "300活跃奖励")

		活跃数据[id].领取400活跃 = true

		常规提示(id, "#Y领取300活跃奖励成功\n获得#R" .. 经验 .. "#Y点经验、#R" .. 经验 .. "#Y银子")
	elseif 数据.序列 == 5 and 活跃数据[id].活跃度 >= 350 and 活跃数据[id].领取500活跃 == false then
		经验 = 等级 * 1000

		添加活动次数(id, "活跃次数")
		玩家数据[id].角色:添加银子(经验, "350活跃奖励")
		玩家数据[id].角色:添加经验(经验, "350活跃奖励", 1)
		添加仙玉(500, 玩家数据[id].账号, id, "350活跃奖励")

		if 取随机数() <= 50 then
			奖励名称[id] = 快捷给道具(id, "制造指南书", 取随机数(10, 11))
		else
			奖励名称[id] = 快捷给道具(id, "百炼精铁", 取随机数(10, 11))
		end

		活跃数据[id].领取500活跃 = true

		if 取随机数(1, 1000) <= 1 then
			local 模型 = 取随机神兽[取随机数(1, #取随机神兽)]

			玩家数据[id].召唤兽:添加召唤兽(模型, nil, nil, true, 0, nil)
			常规提示(id, "#Y恭喜你，获得神兽" .. 模型)
			发送公告("#G玩家#R" .. 玩家数据[id].角色.数据.名称 .. "#G在完成每日活跃日常中，领取350活跃奖励，获得了#R神兽" .. 模型 .. "#G一只，大家一起来鄙视他吧！！！")
		end

		常规提示(id, "#Y领取350活跃奖励成功\n获得#R" .. 经验 .. "#Y点经验、#R" .. 经验 .. "#Y银子")
	else
		常规提示(id, "#Y当前活跃度不够或已领取该奖励")

		return
	end
end

function 系统处理类:获取签到数据(id)
	self.当月天数 = os.date("%d", os.time({
		day = 0,
		year = os.date("%Y"),
		month = os.date("%m") + 1
	}))
	self.月份 = tonumber(os.date("%m", os.time()))
	self.几号 = tonumber(os.date("%d", os.time()))

	if 签到数据[id] ~= nil then
		if 签到数据[id][self.月份] == nil then
			签到数据[id] = {
				[self.月份] = {},
				[self.月份] = {
					累计签到 = 0,
					当月天数 = self.当月天数,
					几号 = self.几号,
					月份 = self.月份
				}
			}

			for i = 1, self.当月天数 do
				if 签到数据[id][self.月份][i] == nil then
					签到数据[id][self.月份][i] = false
				end
			end
		end
	else
		签到数据[id] = {
			[self.月份] = {},
			[self.月份] = {
				累计签到 = 0,
				当月天数 = self.当月天数,
				几号 = self.几号,
				月份 = self.月份
			}
		}

		for i = 1, self.当月天数 do
			if 签到数据[id][self.月份][i] == nil then
				签到数据[id][self.月份][i] = false
			end
		end
	end

	if 签到数据[id][self.月份].几号 ~= self.几号 then
		签到数据[id][self.月份].几号 = self.几号
	end

	发送数据(玩家数据[id].连接id, 90, 签到数据[id][self.月份])
end

function 系统处理类:签到处理(id, 数据)
	local 累计次数 = 签到数据[id][数据.月份].累计签到

	if 活跃数据[id].活跃度 < 100 then
		常规提示(id, "#Y签到需每日的活跃度达到100以上，少侠的活跃度不够，无法签到!")

		return
	end

	if 玩家数据[id].角色.数据.等级 < 30 then
		常规提示(id, "#Y签到需等级达到30级以上，少侠的等级不够，无法签到!")

		return
	end

	if 签到数据[id][数据.月份][数据.几号] == true then
		常规提示(id, "#Y少侠今日已经签到过了!")

		return
	else
		签到数据[id][数据.月份][数据.几号] = true
		签到数据[id][数据.月份].累计签到 = 累计次数 + 1
		累计次数 = 累计次数 + 1

		self:签到奖励处理(id, 累计次数)
		发送数据(玩家数据[id].连接id, 90.1, 签到数据[id][数据.月份])
	end
end

function 系统处理类:签到奖励处理(id, 累计)
	self.经验奖励 = math.floor(玩家数据[id].角色.数据.等级 * 500 * 累计)

	玩家数据[id].角色:添加经验(self.经验奖励, "签到奖励", 1)
	玩家数据[id].角色:添加银子(self.经验奖励, "签到奖励")
	常规提示(id, "#Y恭喜你！签到成功获得大量经验银子奖励！")

	if 累计 == 7 then
		礼包奖励类:随机装备(id, 100, "无级别限制", "专用")
		玩家数据[id].道具:给予道具(id, "修炼果", 1)
		玩家数据[id].道具:给予道具(id, "九转金丹", 1, 100)
		玩家数据[id].角色:添加经验(self.经验奖励, "签到奖励", 1)
		玩家数据[id].角色:添加银子(self.经验奖励, "签到奖励")
		添加仙玉(1000, 玩家数据[id].账号, id, "签到奖励")
		常规提示(id, [[
#Y恭喜你！签到成功获得大量经验银子
1000仙玉
1个修炼果
1个九转金丹]])
	elseif 累计 == 14 then
		礼包奖励类:随机装备(id, 100, "无级别限制", "专用")
		玩家数据[id].道具:给予道具(id, "高级魔兽要诀")
		玩家数据[id].道具:给予道具(id, "高级召唤兽内丹")
		玩家数据[id].道具:给予道具(id, "召唤兽内丹")
		玩家数据[id].角色:添加经验(self.经验奖励, "签到奖励", 1)
		玩家数据[id].角色:添加银子(self.经验奖励, "签到奖励")
		添加仙玉(3000, 玩家数据[id].账号, id, "签到奖励")
		常规提示(id, [[
#Y恭喜你！签到成功获得大量经验银子
3000仙玉
高级魔兽要诀
高级召唤兽内丹]])
	elseif 累计 == 21 then
		礼包奖励类:随机装备(id, 110, "无级别限制", "专用")
		玩家数据[id].角色:添加经验(self.经验奖励, "签到奖励", 1)
		玩家数据[id].角色:添加银子(self.经验奖励, "签到奖励")
		添加仙玉(5000, 玩家数据[id].账号, id, "签到奖励")
		常规提示(id, "#Y恭喜你！签到成功获得大量经验银子\n5000仙玉")
	elseif 累计 == 28 then
		礼包奖励类:随机装备(id, 120, "无级别限制", "专用")
		玩家数据[id].角色:添加经验(self.经验奖励, "签到奖励", 1)
		玩家数据[id].角色:添加银子(self.经验奖励, "签到奖励")
		添加仙玉(10000, 玩家数据[id].账号, id, "签到奖励")
		常规提示(id, "#Y恭喜你！签到成功获得大量经验银子\n10000仙玉\n#G120级无级别装备")
	end
end

function 系统处理类:获取点卡数据(id)
	local 点卡 = f函数.读配置(程序目录 .. "data\\" .. 玩家数据[id].账号 .. "\\账号信息.txt", "账号配置", "点卡")

	if 点卡 == nil or 点卡 == "" or 点卡 == "空" then
		f函数.写配置(程序目录 .. "data\\" .. 玩家数据[id].账号 .. "\\账号信息.txt", "账号配置", "点卡", 0)

		点卡 = 0
	end

	发送数据(玩家数据[id].连接id, 92, {
		兑换比例 = 兑换比例,
		点卡 = 点卡
	})
end

function 系统处理类:获取VIP数据(id)
	if VIP数据[id] ~= nil then
		if VIP数据[id].VIP经验 == nil then
			VIP数据[id].VIP经验 = 0
			VIP数据[id].VIP1状态 = false
			VIP数据[id].VIP2状态 = false
			VIP数据[id].VIP3状态 = false
			VIP数据[id].VIP4状态 = false
			VIP数据[id].VIP5状态 = false
		end
	else
		VIP数据[id] = {
			VIP经验 = 0,
			VIP1状态 = false,
			VIP2状态 = false,
			VIP3状态 = false,
			VIP4状态 = false,
			VIP5状态 = false
		}
	end

	local 点卡 = f函数.读配置(程序目录 .. "data\\" .. 玩家数据[id].账号 .. "\\账号信息.txt", "账号配置", "点卡")

	if 点卡 == nil or 点卡 == "" or 点卡 == "空" then
		f函数.写配置(程序目录 .. "data\\" .. 玩家数据[id].账号 .. "\\账号信息.txt", "账号配置", "点卡", 0)

		点卡 = 0
	end

	发送数据(玩家数据[id].连接id, 91, {
		充值比例 = 充值比例,
		VIP数据 = VIP数据[id],
		兑换比例 = 兑换比例,
		点卡 = 点卡
	})
end

function 系统处理类:VIP领取奖励处理(id, 数据)
	if 玩家数据[id].角色:取道具格子2() <= 12 then
		常规提示(id, "#Y请先清理下背包再来领取奖励")

		return
	end

	local VIP1经验 = 充值比例 * 188
	local VIP2经验 = 充值比例 * 388
	local VIP3经验 = 充值比例 * 888
	local VIP4经验 = 充值比例 * 2888
	local VIP5经验 = 充值比例 * 4888

	if 数据.序列 == "VIP1" then
		if VIP1经验 <= VIP数据[id].VIP经验 and VIP数据[id].VIP1状态 == false then
			玩家数据[id].道具:给予道具(id, "30级装备礼包")
			玩家数据[id].角色:添加银子(100000, "VIP1礼包")
			玩家数据[id].道具:给予道具(id, "九转金丹", 5, 500)
			添加仙玉(100, 玩家数据[id].账号, id, "VIP1礼包")
			玩家数据[id].角色:添加称谓(id, "VIP1")

			VIP数据[id].VIP1状态 = true
		elseif VIP数据[id].VIP1状态 then
			常规提示(id, "#Y您已经领取过VIP1礼包，无法重复领取！")

			return
		else
			常规提示(id, "#Y领取VIP1礼包所需经验：#R" .. VIP1经验 .. "#Y，您当前经验为：#R" .. VIP数据[id].VIP经验)

			return
		end
	elseif 数据.序列 == "VIP2" then
		if VIP2经验 <= VIP数据[id].VIP经验 and VIP数据[id].VIP2状态 == false then
			玩家数据[id].道具:给予道具(id, "40级装备礼包")
			玩家数据[id].角色:添加银子(100000, "VIP2礼包")
			玩家数据[id].道具:给予道具(id, "九转金丹", 10, 500)
			玩家数据[id].角色:添加称谓(id, "VIP2")

			VIP数据[id].VIP2状态 = true
		elseif VIP数据[id].VIP2状态 then
			常规提示(id, "#Y您已经领取过VIP2礼包，无法重复领取！")

			return
		else
			常规提示(id, "#Y领取VIP2礼包所需经验：#R" .. VIP2经验 .. "#Y，您当前经验为：#R" .. VIP数据[id].VIP经验)

			return
		end
	elseif 数据.序列 == "VIP3" then
		if VIP3经验 <= VIP数据[id].VIP经验 and VIP数据[id].VIP3状态 == false then
			玩家数据[id].道具:给予道具(id, "50级装备礼包")
			玩家数据[id].角色:添加银子(100000, "VIP3礼包")
			玩家数据[id].道具:给予道具(id, "九转金丹", 15, 500)
			玩家数据[id].角色:添加称谓(id, "VIP3")

			VIP数据[id].VIP3状态 = true
		elseif VIP数据[id].VIP3状态 then
			常规提示(id, "#Y您已经领取过VIP3礼包，无法重复领取！")

			return
		else
			常规提示(id, "#Y领取VIP3礼包所需经验：#R" .. VIP3经验 .. "#Y，您当前经验为：#R" .. VIP数据[id].VIP经验)

			return
		end
	elseif 数据.序列 == "VIP4" then
		if VIP4经验 <= VIP数据[id].VIP经验 and VIP数据[id].VIP4状态 == false then
			玩家数据[id].道具:给予道具(id, "60级装备礼包")
			玩家数据[id].角色:添加银子(100000, "VIP4礼包")
			玩家数据[id].道具:给予道具(id, "九转金丹", 20, 500)
			玩家数据[id].角色:添加称谓(id, "VP4")

			VIP数据[id].VIP4状态 = true
		elseif VIP数据[id].VIP4状态 then
			常规提示(id, "#Y您已经领取过VIP4礼包，无法重复领取！")

			return
		else
			常规提示(id, "#Y领取VIP4礼包所需经验：#R" .. VIP4经验 .. "#Y，您当前经验为：#R" .. VIP数据[id].VIP经验)

			return
		end
	elseif 数据.序列 == "VIP5" then
		if VIP5经验 <= VIP数据[id].VIP经验 and VIP数据[id].VIP5状态 == false then
			玩家数据[id].道具:给予道具(id, "70级装备礼包")
			玩家数据[id].角色:添加银子(100000, "VIP5礼包")
			玩家数据[id].道具:给予道具(id, "九转金丹", 25, 500)
			玩家数据[id].角色:添加称谓(id, "VP5")

			VIP数据[id].VIP5状态 = true
		elseif VIP数据[id].VIP5状态 then
			常规提示(id, "#Y您已经领取过VIP5礼包，无法重复领取！")

			return
		else
			常规提示(id, "#Y领取VIP5礼包所需经验：#R" .. VIP5经验 .. "#Y，您当前经验为：#R" .. VIP数据[id].VIP经验)

			return
		end
	end
end

function 系统处理类:显示(x, y)
end

return 系统处理类
